From 25bb72ca887f3a9b9089aa7cc607e228afc989b5 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 16:36:43 -0400 Subject: [PATCH 01/34] Add EnvSolverKV.hh --- src/envelope/EnvSolverKV.hh | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 src/envelope/EnvSolverKV.hh diff --git a/src/envelope/EnvSolverKV.hh b/src/envelope/EnvSolverKV.hh new file mode 100644 index 00000000..b0cf4eab --- /dev/null +++ b/src/envelope/EnvSolverKV.hh @@ -0,0 +1,34 @@ +#ifndef ENV_SOLVER_KV_H +#define ENV_SOLVER_KV_H + +#include "Bunch.hh" +#include "CppPyWrapper.hh" + +using namespace std; + +/** Envelope solver for upright KV distribution in uncoupled lattice. + +The first particle in the bunch is used to track the +envelope parameters. The envelope parameters are use to apply space charge +kicks to the other particles in the bunch. + +This class does not yet handle boudary conditions or dispersion. + */ +class EnvSolverKV : public OrbitUtils::CppPyWrapper { +public: + EnvSolverKV(double perveance, double emittanceX, double emittanceY); + void trackBunch(Bunch *bunch, double length); + void setPerveance(double perveance); + void setEmittanceX(double emittanceX); + void setEmittanceY(double emittanceY); + double getPerveance(); + double getEmittanceX(); + double getEmittanceY(); + +private: + double Q; // beam perveance + double epsX; // (4 * sqrt( - )) + double epsY; // (4 * sqrt( - )) +}; + +#endif \ No newline at end of file From d95494f5fee137db9c7c042c1eb1ec1a752c98e8 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 16:50:21 -0400 Subject: [PATCH 02/34] Add EnvSolverKV.cc --- src/envelope/EnvSolverKV.cc | 88 +++++++++++++++++++++++++++++++++++++ src/envelope/EnvSolverKV.hh | 10 ++--- 2 files changed, 93 insertions(+), 5 deletions(-) create mode 100644 src/envelope/EnvSolverKV.cc diff --git a/src/envelope/EnvSolverKV.cc b/src/envelope/EnvSolverKV.cc new file mode 100644 index 00000000..d4ff5e1d --- /dev/null +++ b/src/envelope/EnvSolverKV.cc @@ -0,0 +1,88 @@ +#include "EnvSolverKV.hh" + +EnvSolverKV::EnvSolverKV(double perveance, double emittance_x, double emittance_y) : CppPyWrapper(NULL) { + Q = perveance; + eps_x = emittance_x; + eps_y = emittance_y; +} + +void EnvSolverKV::setPerveance(double perveance) { + Q = perveance; +} + +void EnvSolverKV::setEmittanceX(double emittance) { + eps_x = emittance; +} + +void EnvSolverKV::setEmittanceY(double emittance) { + eps_y = emittance; +} + +double EnvSolverKV::getPerveance() { + return Q; +} + +double EnvSolverKV::getEmittanceX() { + return eps_x; +} + +double EnvSolverKV::getEmittanceY() { + return eps_y; +} + +void EnvSolverKV::trackBunch(Bunch *bunch, double length) { + // Track envelope + double cx = bunch->x(0); + double cy = bunch->y(0); + double sc_term = 2.0 * Q / (cx + cy); + double eps_x_term = (eps_x * eps_x) / (cx * cx * cx); + double eps_y_term = (eps_y * eps_y) / (cy * cy * cy); + bunch->xp(0) += length * (sc_term + eps_x_term); + bunch->yp(0) += length * (sc_term + eps_y_term); + + // Track test particles + double cx2 = cx * cx; + double cy2 = cy * cy; + + double x; + double y; + double x2; + double y2; + + double B; + double C; + double Dx; + double Dy; + double t1; + + double delta_xp; + double delta_yp; + bool inside; + + for (int i = 1; i < bunch->getSize(); i++) { + x = bunch->x(i); + y = bunch->y(i); + + x2 = x * x; + y2 = y * y; + + inside = ((x2 / cx2) + (y2 / cy2)) <= 1.0; + + if (inside) { + delta_xp = sc_term * x / cx; + delta_yp = sc_term * y / cy; + } + else { + // https://arxiv.org/abs/physics/0108040 + B = x2 + y2 - cx2 - cy2; + C = x2 * cy2 + y2 * cx2 - cx2 * cy2; + t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; + Dx = pow(cx2 + t1, 0.5); + Dy = pow(cy2 + t1, 0.5); + delta_xp = 2.0 * Q * x / (Dx * (Dx + Dy)); + delta_yp = 2.0 * Q * y / (Dy * (Dx + Dy)); + } + bunch->xp(i) += delta_xp; + bunch->yp(i) += delta_yp; + } + } \ No newline at end of file diff --git a/src/envelope/EnvSolverKV.hh b/src/envelope/EnvSolverKV.hh index b0cf4eab..28f7bccd 100644 --- a/src/envelope/EnvSolverKV.hh +++ b/src/envelope/EnvSolverKV.hh @@ -16,19 +16,19 @@ This class does not yet handle boudary conditions or dispersion. */ class EnvSolverKV : public OrbitUtils::CppPyWrapper { public: - EnvSolverKV(double perveance, double emittanceX, double emittanceY); + EnvSolverKV(double perveance, double emittance_x, double emittance_y); void trackBunch(Bunch *bunch, double length); void setPerveance(double perveance); - void setEmittanceX(double emittanceX); - void setEmittanceY(double emittanceY); + void setEmittanceX(double emittance); + void setEmittanceY(double emittance); double getPerveance(); double getEmittanceX(); double getEmittanceY(); private: double Q; // beam perveance - double epsX; // (4 * sqrt( - )) - double epsY; // (4 * sqrt( - )) + double eps_x; // (4 * sqrt( - )) + double eps_y; // (4 * sqrt( - )) }; #endif \ No newline at end of file From 949e0346cf43b58ad6e5bfce849f834da7c70d8b Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 16:50:58 -0400 Subject: [PATCH 03/34] Add note that kicks outside beam envelope are untested --- src/envelope/EnvSolverKV.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/envelope/EnvSolverKV.cc b/src/envelope/EnvSolverKV.cc index d4ff5e1d..39e6b521 100644 --- a/src/envelope/EnvSolverKV.cc +++ b/src/envelope/EnvSolverKV.cc @@ -74,6 +74,7 @@ void EnvSolverKV::trackBunch(Bunch *bunch, double length) { } else { // https://arxiv.org/abs/physics/0108040 + // UNTESTED! B = x2 + y2 - cx2 - cy2; C = x2 * cy2 + y2 * cx2 - cx2 * cy2; t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; From f8d2fa842f89cf8f68f097620d4b1ef90c5e735b Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 16:52:02 -0400 Subject: [PATCH 04/34] Add core/envelope_init.cc --- src/core/envelope_init.cc | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/core/envelope_init.cc diff --git a/src/core/envelope_init.cc b/src/core/envelope_init.cc new file mode 100644 index 00000000..90f25775 --- /dev/null +++ b/src/core/envelope_init.cc @@ -0,0 +1,4 @@ +#include "wrap_envelope.hh" +PyMODINIT_FUNC PyInit_envelope(void) { + return wrap_envelope::initenvelope(); +} From 82081867a5c2d7bd6c96cb9e65090d26ab4654d6 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:00:28 -0400 Subject: [PATCH 05/34] Add wrapper functions --- src/envelope/wrap_env_solver_kv.cc | 198 +++++++++++++++++++++++++++++ src/envelope/wrap_env_solver_kv.hh | 18 +++ src/envelope/wrap_envelope.cc | 35 +++++ 3 files changed, 251 insertions(+) create mode 100644 src/envelope/wrap_env_solver_kv.cc create mode 100644 src/envelope/wrap_env_solver_kv.hh create mode 100644 src/envelope/wrap_envelope.cc diff --git a/src/envelope/wrap_env_solver_kv.cc b/src/envelope/wrap_env_solver_kv.cc new file mode 100644 index 00000000..18f8af73 --- /dev/null +++ b/src/envelope/wrap_env_solver_kv.cc @@ -0,0 +1,198 @@ +#include + +#include "orbit_mpi.hh" +#include "pyORBIT_Object.hh" + +#include "EnvSolverKV.hh" +#include "wrap_bunch.hh" +#include "wrap_envelope.hh" +#include "wrap_env_solver_kv.hh" + +namespace wrap_envelope { + +#ifdef __cplusplus +extern "C" { +#endif + +// Constructor for Python class wrapping EnvSolverKV instance. +// It never will be called directly. +static PyObject *EnvSolverKV_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + pyORBIT_Object *self; + self = (pyORBIT_Object *)type->tp_alloc(type, 0); + self->cpp_obj = NULL; + return (PyObject *)self; +} + +// Initialization of Python EnvSolverKV class. +// This is implementation of the __init__ method. +static int EnvSolverKV_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { + double perveance = 0.0; + double eps_x = 1.0; + double eps_y = 1.0; + self->cpp_obj = new EnvSolverKV(perveance, eps_x, eps_y); + ((EnvSolverKV *)self->cpp_obj)->setPyWrapper((PyObject *)self); + return 0; +} + +// Method: trackBunch(Bunch* bunch, double length) +static PyObject *EnvSolverKV_trackBunch(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + PyObject *pyBunch; + double length; + if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { + ORBIT_MPI_Finalize("PyEnvSolverKV - trackBunch(Bunch* bunch, double length) - parameters are needed."); + } + PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); + if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { + ORBIT_MPI_Finalize("PyEnvSolverKV - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); + } + Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; + cpp_EnvSolverKV->trackBunch(cpp_bunch, length); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setPerveance(double perveance) +static PyObject *EnvSolverKV_setPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + double perveance; + if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { + ORBIT_MPI_Finalize("PyEnvSolverKV - setPerveance(double perveance) - parameters are needed."); + } + cpp_EnvSolverKV->setPerveance(perveance); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setEmittanceX(double emittance_x) +static PyObject *EnvSolverKV_setEmittanceX(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + double emittance_x; + if (!PyArg_ParseTuple(args, "d:setEmittanceX", &emittance_x)) { + ORBIT_MPI_Finalize("PyEnvSolverKV - setEmittanceX(double emittance_x) - parameters are needed."); + } + cpp_EnvSolverKV->setEmittanceX(emittance_x); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setEmittanceY(double emittance_y) +static PyObject *EnvSolverKV_setEmittanceY(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + double emittance_y; + if (!PyArg_ParseTuple(args, "d:setEmittanceY", &emittance_y)) { + ORBIT_MPI_Finalize("PyEnvSolverKV - setEmittanceY(double emittance_y) - parameters are needed."); + } + cpp_EnvSolverKV->setEmittanceY(emittance_y); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: getPerveance() +static PyObject *EnvSolverKV_getPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + double perveance = cpp_EnvSolverKV->getPerveance(); + return Py_BuildValue("d", perveance); +} + +// Method: getEmittanceX() +static PyObject *EnvSolverKV_getEmittanceX(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + double eps_x = cpp_EnvSolverKV->getEmittanceX(); + return Py_BuildValue("d", eps_x); +} + +// Method: getEmittanceY() +static PyObject *EnvSolverKV_getEmittanceY(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; + double eps_y = cpp_EnvSolverKV->getEmittanceY(); + return Py_BuildValue("d", eps_y); +} + +// Destructor for python EnvSolverKV class (__del__ method) +static void EnvSolverKV_del(pyORBIT_Object *self) { + EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)self->cpp_obj; + delete cpp_EnvSolverKV; + self->ob_base.ob_type->tp_free((PyObject *)self); +} + +// Definition of Python EnvSolverKV wrapper class methods. +// They will be available from the Python level. +static PyMethodDef EnvSolverKVClassMethods[] = { + {"getEmittanceX", EnvSolverKV_getEmittanceX, METH_VARARGS, "Get emittance (x)."}, + {"getEmittanceY", EnvSolverKV_getEmittanceY, METH_VARARGS, "Get emittance (y)."}, + {"getPerveance", EnvSolverKV_getPerveance, METH_VARARGS, "Get space charge perveance."}, + {"setEmittanceX", EnvSolverKV_setEmittanceX, METH_VARARGS, "Set emittance (x)."}, + {"setEmittanceY", EnvSolverKV_setEmittanceY, METH_VARARGS, "Set emittance (y)."}, + {"setPerveance", EnvSolverKV_setPerveance, METH_VARARGS, "Set space charge perveance."}, + {"trackBunch", EnvSolverKV_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, + {NULL} +}; + +// Definition of Python EnvSolverKV wrapper class members. +// They will be available from the Python level. +static PyMemberDef EnvSolverKVClassMembers[] = { + {NULL}}; + +// New python EnvSolverKV wrapper type definition. +static PyTypeObject pyORBIT_EnvSolverKV_Type = { + PyVarObject_HEAD_INIT(NULL, 0) "EnvSolverKV", /*tp_name*/ + sizeof(pyORBIT_Object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)EnvSolverKV_del, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "The EnvSolverKV python wrapper", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + EnvSolverKVClassMethods, /* tp_methods */ + EnvSolverKVClassMembers, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)EnvSolverKV_init, /* tp_init */ + 0, /* tp_alloc */ + EnvSolverKV_new, /* tp_new */ +}; + +// Initialization function of the pyEnvSolverKV class +void initEnvSolverKV(PyObject *module) { + if (PyType_Ready(&pyORBIT_EnvSolverKV_Type) < 0) + return; + Py_INCREF(&pyORBIT_EnvSolverKV_Type); + PyModule_AddObject(module, "EnvSolverKV", (PyObject *)&pyORBIT_EnvSolverKV_Type); +} + +#ifdef __cplusplus +} +#endif + +// end of namespace wrap_envelope +} // namespace wrap_envelope diff --git a/src/envelope/wrap_env_solver_kv.hh b/src/envelope/wrap_env_solver_kv.hh new file mode 100644 index 00000000..8c3b5a74 --- /dev/null +++ b/src/envelope/wrap_env_solver_kv.hh @@ -0,0 +1,18 @@ +#ifndef WRAP_ENV_SOLVER_KV_H +#define WRAP_ENV_SOLVER_KV_H + +#include "Python.h" + +#ifdef __cplusplus +extern "C" { +#endif + +namespace wrap_envelope { +void initEnvSolverKV(PyObject *module); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/envelope/wrap_envelope.cc b/src/envelope/wrap_envelope.cc new file mode 100644 index 00000000..bd69a80c --- /dev/null +++ b/src/envelope/wrap_envelope.cc @@ -0,0 +1,35 @@ +#include + +#include "orbit_mpi.hh" +#include "pyORBIT_Object.hh" + +#include "wrap_bunch.hh" +#include "wrap_envelope.hh" +#include "wrap_env_solver_kv.hh" + +namespace wrap_envelope { + +#ifdef __cplusplus +extern "C" { +#endif + +static PyMethodDef envelopeModuleMethods[] = {{NULL, NULL}}; + +static struct PyModuleDef cModPyDem = { + PyModuleDef_HEAD_INIT, + "envelope", "Beam envelope solvers", + -1, + envelopeModuleMethods +}; + +PyMODINIT_FUNC initenvelope() { + PyObject *module = PyModule_Create(&cModPyDem); + wrap_envelope::initEnvSolverKV(module); + return module; +} + +#ifdef __cplusplus +} +#endif + +} From a49923d5c89ad5392ade2c5dd481947ef29d3865 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:02:38 -0400 Subject: [PATCH 06/34] Edit meson.build --- src/meson.build | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/meson.build b/src/meson.build index 841fc403..7276d460 100644 --- a/src/meson.build +++ b/src/meson.build @@ -246,7 +246,10 @@ sources = files([ 'teapot/wrap_teapotbase.cc', 'teapot/wrap_matrix_generator.cc', 'teapot/teapotbase.cc', - 'teapot/MatrixGenerator.cc' + 'teapot/MatrixGenerator.cc', + 'envelope/EnvSolverKV.cc', + 'envelope/wrap_env_solver_kv.cc', + 'envelope/wrap_envelope.cc', ]) inc = include_directories([ python.get_variable('INCLUDEPY', ''), @@ -277,7 +280,7 @@ inc = include_directories([ 'orbit', 'utils/integration', 'orbit/Apertures' - + 'envelope', ]) @@ -427,3 +430,12 @@ python.extension_module('error_base', install: true, subdir: 'orbit/core', ) + +python.extension_module('envelope', + sources: [base + '/envelope_init.cc'], + include_directories: inc, + cpp_args: ['-fPIC', '-std=c++11'], + dependencies: [core_dep], + install: true, + subdir: 'orbit/core', +) From 7b957b3bc81460de3b0a74faa06d4a72eea31dbf Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:03:24 -0400 Subject: [PATCH 07/34] Forget comma --- src/meson.build | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/meson.build b/src/meson.build index 7276d460..afe4d0fe 100644 --- a/src/meson.build +++ b/src/meson.build @@ -279,7 +279,7 @@ inc = include_directories([ 'orbit/BunchDiagnostics', 'orbit', 'utils/integration', - 'orbit/Apertures' + 'orbit/Apertures', 'envelope', ]) From 194c78125c771340d9c65b3682a4da9b93534615 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:05:11 -0400 Subject: [PATCH 08/34] Add wrap_envelope.hh --- src/envelope/wrap_envelope.hh | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 src/envelope/wrap_envelope.hh diff --git a/src/envelope/wrap_envelope.hh b/src/envelope/wrap_envelope.hh new file mode 100644 index 00000000..7d14333a --- /dev/null +++ b/src/envelope/wrap_envelope.hh @@ -0,0 +1,18 @@ +#ifndef WRAP_ENVELOPE_MODULE_HH_ +#define WRAP_ENVELOPE_MODULE_HH_ + +#include "Python.h" + +#ifdef __cplusplus +extern "C" { +#endif + +namespace wrap_envelope { + PyMODINIT_FUNC initenvelope(); +} + +#ifdef __cplusplus +} +#endif + +#endif /*WRAP_ENVELOPE_MODULE_HH_*/ From ffb607caa0e0da6bf82582bf4c80419704da937b Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:13:30 -0400 Subject: [PATCH 09/34] Add EnvSolverDanilov.cc --- src/envelope/EnvSolverDanilov.cc | 120 +++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 src/envelope/EnvSolverDanilov.cc diff --git a/src/envelope/EnvSolverDanilov.cc b/src/envelope/EnvSolverDanilov.cc new file mode 100644 index 00000000..e77390a2 --- /dev/null +++ b/src/envelope/EnvSolverDanilov.cc @@ -0,0 +1,120 @@ +#include "EnvSolverDanilov.hh" + +EnvSolverDanilov::EnvSolverDanilov(double perveance) : CppPyWrapper(NULL) { + Q = perveance; +} + +void EnvSolverDanilov::setPerveance(double perveance) { + Q = perveance; +} + +double EnvSolverDanilov::getPerveance() { + return Q; +} + +void EnvSolverDanilov::trackBunch(Bunch *bunch, double length) { + // Compute ellipse size and orientation. + double a = bunch->x(0); + double b = bunch->x(1); + double e = bunch->y(0); + double f = bunch->y(1); + double ap = bunch->xp(0); + double bp = bunch->xp(1); + double ep = bunch->yp(0); + double fp = bunch->yp(1); + + double cov_xx = a * a + b * b; // 4 * + double cov_yy = e * e + f * f; // 4 * + double cov_xy = a * e + b * f; // 4 * + + double phi = -0.5 * atan2(2.0 * cov_xy, cov_xx - cov_yy); + + double _cos = cos(phi); + double _sin = sin(phi); + double cos2 = _cos * _cos; + double sin2 = _sin * _sin; + double sin_cos = _sin * _cos; + + double cxn = sqrt(abs(cov_xx * cos2 + cov_yy * sin2 - 2.0 * cov_xy * sin_cos)); + double cyn = sqrt(abs(cov_xx * sin2 + cov_yy * cos2 + 2.0 * cov_xy * sin_cos)); + double factor = length * (2.0 * Q / (cxn + cyn)); + + // Track envelope + if (cxn > 0.0) { + bunch->xp(0) += factor * (a * cos2 - e * sin_cos) / cxn; + bunch->xp(1) += factor * (b * cos2 - f * sin_cos) / cxn; + bunch->yp(0) += factor * (e * sin2 - a * sin_cos) / cxn; + bunch->yp(1) += factor * (f * sin2 - b * sin_cos) / cxn; + } + if (cyn > 0.0) { + bunch->xp(0) += factor * (a * sin2 + e * sin_cos) / cyn; + bunch->xp(1) += factor * (b * sin2 + f * sin_cos) / cyn; + bunch->yp(0) += factor * (e * cos2 + a * sin_cos) / cyn; + bunch->yp(1) += factor * (f * cos2 + b * sin_cos) / cyn; + } + + // Track test particles + double cxn2 = cxn * cxn; + double cyn2 = cyn * cyn; + double x; + double y; + double x2; + double y2; + + double xn; + double yn; + double xn2; + double yn2; + + double t1; + double B; + double C; + double Dx; + double Dy; + + double delta_xp; + double delta_yp; + double delta_xpn; + double delta_ypn; + bool in_ellipse; + + for (int i = 2; i < bunch->getSize(); i++) { + x = bunch->x(i); + y = bunch->y(i); + + x2 = x * x; + y2 = y * y; + + xn = x * _cos - y * _sin; + yn = x * _sin + y * _cos; + + xn2 = xn * xn; + yn2 = yn * yn; + + in_ellipse = ((xn2 / cxn2) + (yn2 / cyn2)) <= 1.0; + + if (in_ellipse) { + if (cxn > 0.0) { + delta_xpn = factor * xn / cxn; + } + if (cyn > 0.0) { + delta_ypn = factor * yn / cyn; + } + } + else { + // https://arxiv.org/abs/physics/0108040 + // UNTESTED! + B = xn2 + yn2 - cxn2 - cyn2; + C = xn2 * cyn2 + yn2 * cxn2 - cxn2 * cyn2; + t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; + Dx = pow(cxn2 + t1, 0.5); + Dy = pow(cyn2 + t1, 0.5); + delta_xpn = 2.0 * Q * xn / (Dx * (Dx + Dy)); + delta_ypn = 2.0 * Q * yn / (Dy * (Dx + Dy)); + } + delta_xp = +delta_xpn * _cos + delta_ypn * _sin; + delta_yp = -delta_xpn * _sin + delta_ypn * _cos; + bunch->xp(i) += delta_xp; + bunch->yp(i) += delta_yp; + } +} From 080d3e998446161f088a9b9002e0470c7784e603 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:16:22 -0400 Subject: [PATCH 10/34] Add EnvSolverDanilov.hh --- src/envelope/EnvSolverDanilov.hh | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 src/envelope/EnvSolverDanilov.hh diff --git a/src/envelope/EnvSolverDanilov.hh b/src/envelope/EnvSolverDanilov.hh new file mode 100644 index 00000000..6b28f515 --- /dev/null +++ b/src/envelope/EnvSolverDanilov.hh @@ -0,0 +1,36 @@ +#ifndef ENV_SOLVER_DANILOV_H +#define ENV_SOLVER_DANILOV_H + +#include "Bunch.hh" +#include "CppPyWrapper.hh" + +using namespace std; + +/** Envelope solver for the Danilov distribution (KV distribution with + zero emittance in one plane). + + The ellipse in the x-y plane can be parameterized as [1]: + x = a * cos(psi) + b * sin(psi), + y = e * cos(psi) + f * sin(psi), + where 0 <= psi <= 2pi. The first two particles in the bunch are used to track + the envelope parameters {a, b, e, f}, which are used to apply space charge + kicks to the other particles in the bunch. + + References + ---------- + [1] V. Danilov, S. Cousineau, S. Henderson, and J. Holmes, "Self-consistent time + dependent two dimensional and three dimensional space charge distributions with + linear force", PPRAB 6, 74–85 (2003). +*/ +class EnvSolverDanilov : public OrbitUtils::CppPyWrapper { +public: + EnvSolverDanilov(double perveanceQ); + void trackBunch(Bunch *bunch, double length); + void setPerveance(double perveance); + double getPerveance(); + +private: + double Q; // beam perveance +}; + +#endif \ No newline at end of file From 94b47c7c3133ce24178c2e0bef75754fc9ac501b Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:21:18 -0400 Subject: [PATCH 11/34] Add .ipynb_checkpoints to gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 47650c0e..9291a157 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,4 @@ PyORBIT.egg-info *.so .*.swp .eggs +.ipynb_checkpoints From 5845c532d90e49f1cb576476bf899818dcb3c278 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:23:35 -0400 Subject: [PATCH 12/34] Fix wrapper for Danilov envelope solver --- src/envelope/wrap_env_solver_danilov.cc | 150 ++++++++++++++++++++++++ src/envelope/wrap_env_solver_danilov.hh | 18 +++ src/envelope/wrap_envelope.cc | 3 + src/meson.build | 2 + 4 files changed, 173 insertions(+) create mode 100644 src/envelope/wrap_env_solver_danilov.cc create mode 100644 src/envelope/wrap_env_solver_danilov.hh diff --git a/src/envelope/wrap_env_solver_danilov.cc b/src/envelope/wrap_env_solver_danilov.cc new file mode 100644 index 00000000..fad0b48e --- /dev/null +++ b/src/envelope/wrap_env_solver_danilov.cc @@ -0,0 +1,150 @@ +#include + +#include "orbit_mpi.hh" +#include "pyORBIT_Object.hh" + +#include "EnvSolverDanilov.hh" +#include "wrap_bunch.hh" +#include "wrap_envelope.hh" +#include "wrap_env_solver_danilov.hh" + +namespace wrap_envelope { + +#ifdef __cplusplus +extern "C" { +#endif + +// Constructor for Python class wrapping EnvSolverDanilov instance. +// It never will be called directly. +static PyObject *EnvSolverDanilov_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + pyORBIT_Object *self; + self = (pyORBIT_Object *)type->tp_alloc(type, 0); + self->cpp_obj = NULL; + return (PyObject *)self; +} + +// Initialization of Python EnvSolverDanilov class. +// This is implementation of the __init__ method. +static int EnvSolverDanilov_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { + double perveance = 0.0; + self->cpp_obj = new EnvSolverDanilov(perveance); + ((EnvSolverDanilov *)self->cpp_obj)->setPyWrapper((PyObject *)self); + return 0; +} + +// Method: trackBunch(Bunch* bunch, double length) +static PyObject *EnvSolverDanilov_trackBunch(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverDanilov = (pyORBIT_Object *)self; + EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)pyEnvSolverDanilov->cpp_obj; + PyObject *pyBunch; + double length; + if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { + ORBIT_MPI_Finalize("PyEnvSolverDanilov - trackBunch(Bunch* bunch, double length) - parameters are needed."); + } + PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); + if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { + ORBIT_MPI_Finalize("PyEnvSolverDanilov - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); + } + Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; + cpp_EnvSolverDanilov->trackBunch(cpp_bunch, length); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setPerveance(double perveance) +static PyObject *EnvSolverDanilov_setPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverDanilov = (pyORBIT_Object *)self; + EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)pyEnvSolverDanilov->cpp_obj; + double perveance; + if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { + ORBIT_MPI_Finalize("PyEnvSolverDanilov - setPerveance(double perveance) - parameters are needed."); + } + cpp_EnvSolverDanilov->setPerveance(perveance); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: getPerveance() +static PyObject *EnvSolverDanilov_getPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyEnvSolverDanilov = (pyORBIT_Object *)self; + EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)pyEnvSolverDanilov->cpp_obj; + double perveance = cpp_EnvSolverDanilov->getPerveance(); + return Py_BuildValue("d", perveance); +} + +// Destructor for python EnvSolverDanilov class (__del__ method) +static void EnvSolverDanilov_del(pyORBIT_Object *self) { + EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)self->cpp_obj; + delete cpp_EnvSolverDanilov; + self->ob_base.ob_type->tp_free((PyObject *)self); +} + +// Definition of Python EnvSolverDanilov wrapper class methods. +// They will be available from the Python level. +static PyMethodDef EnvSolverDanilovClassMethods[] = { + {"getPerveance", EnvSolverDanilov_getPerveance, METH_VARARGS, "Get space charge perveance."}, + {"setPerveance", EnvSolverDanilov_setPerveance, METH_VARARGS, "Set space charge perveance."}, + {"trackBunch", EnvSolverDanilov_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, + {NULL} +}; + +// Definition of Python EnvSolverDanilov wrapper class members. +// They will be available from the Python level. +static PyMemberDef EnvSolverDanilovClassMembers[] = { + {NULL}}; + +// New python EnvSolverDanilov wrapper type definition. +static PyTypeObject pyORBIT_EnvSolverDanilov_Type = { + PyVarObject_HEAD_INIT(NULL, 0) "EnvSolverDanilov", /*tp_name*/ + sizeof(pyORBIT_Object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)EnvSolverDanilov_del, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "The EnvSolverDanilov python wrapper", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + EnvSolverDanilovClassMethods, /* tp_methods */ + EnvSolverDanilovClassMembers, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)EnvSolverDanilov_init, /* tp_init */ + 0, /* tp_alloc */ + EnvSolverDanilov_new, /* tp_new */ +}; + +// Initialization function of the pyEnvSolverDanilov class +void initEnvSolverDanilov(PyObject *module) { + if (PyType_Ready(&pyORBIT_EnvSolverDanilov_Type) < 0) + return; + Py_INCREF(&pyORBIT_EnvSolverDanilov_Type); + PyModule_AddObject(module, "EnvSolverDanilov", (PyObject *)&pyORBIT_EnvSolverDanilov_Type); +} + +#ifdef __cplusplus +} +#endif + +// end of namespace wrap_envelope +} // namespace wrap_envelope diff --git a/src/envelope/wrap_env_solver_danilov.hh b/src/envelope/wrap_env_solver_danilov.hh new file mode 100644 index 00000000..4167e72a --- /dev/null +++ b/src/envelope/wrap_env_solver_danilov.hh @@ -0,0 +1,18 @@ +#ifndef WRAP_ENV_SOLVER_DANILOV_H +#define WRAP_ENV_SOLVER_DANILOV_H + +#include "Python.h" + +#ifdef __cplusplus +extern "C" { +#endif + +namespace wrap_envelope { +void initEnvSolverDanilov(PyObject *module); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/envelope/wrap_envelope.cc b/src/envelope/wrap_envelope.cc index bd69a80c..0394f59f 100644 --- a/src/envelope/wrap_envelope.cc +++ b/src/envelope/wrap_envelope.cc @@ -6,6 +6,8 @@ #include "wrap_bunch.hh" #include "wrap_envelope.hh" #include "wrap_env_solver_kv.hh" +#include "wrap_env_solver_danilov.hh" + namespace wrap_envelope { @@ -25,6 +27,7 @@ static struct PyModuleDef cModPyDem = { PyMODINIT_FUNC initenvelope() { PyObject *module = PyModule_Create(&cModPyDem); wrap_envelope::initEnvSolverKV(module); + wrap_envelope::initEnvSolverDanilov(module); return module; } diff --git a/src/meson.build b/src/meson.build index afe4d0fe..78528763 100644 --- a/src/meson.build +++ b/src/meson.build @@ -248,7 +248,9 @@ sources = files([ 'teapot/teapotbase.cc', 'teapot/MatrixGenerator.cc', 'envelope/EnvSolverKV.cc', + 'envelope/EnvSolverDanilov.cc', 'envelope/wrap_env_solver_kv.cc', + 'envelope/wrap_env_solver_danilov.cc', 'envelope/wrap_envelope.cc', ]) inc = include_directories([ From e899576e546fc79940b47db6c51fcac416bca1a7 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:36:20 -0400 Subject: [PATCH 13/34] Change naming pattern to "EnvelopeTracker" --- ...erDanilov.cc => DanilovEnvelopeTracker.cc} | 10 +- ...erDanilov.hh => DanilovEnvelopeTracker.hh} | 8 +- .../{EnvSolverKV.cc => KVEnvelopeTracker.cc} | 18 +- .../{EnvSolverKV.hh => KVEnvelopeTracker.hh} | 8 +- src/envelope/wrap_danilov_envelope_tracker.cc | 150 +++++++++++++ src/envelope/wrap_danilov_envelope_tracker.hh | 18 ++ src/envelope/wrap_env_solver_danilov.cc | 150 ------------- src/envelope/wrap_env_solver_danilov.hh | 18 -- src/envelope/wrap_env_solver_kv.cc | 198 ------------------ src/envelope/wrap_envelope.cc | 8 +- src/envelope/wrap_kv_envelope_tracker.cc | 198 ++++++++++++++++++ ...lver_kv.hh => wrap_kv_envelope_tracker.hh} | 4 +- 12 files changed, 394 insertions(+), 394 deletions(-) rename src/envelope/{EnvSolverDanilov.cc => DanilovEnvelopeTracker.cc} (90%) rename src/envelope/{EnvSolverDanilov.hh => DanilovEnvelopeTracker.hh} (83%) rename src/envelope/{EnvSolverKV.cc => KVEnvelopeTracker.cc} (75%) rename src/envelope/{EnvSolverKV.hh => KVEnvelopeTracker.hh} (80%) create mode 100644 src/envelope/wrap_danilov_envelope_tracker.cc create mode 100644 src/envelope/wrap_danilov_envelope_tracker.hh delete mode 100644 src/envelope/wrap_env_solver_danilov.cc delete mode 100644 src/envelope/wrap_env_solver_danilov.hh delete mode 100644 src/envelope/wrap_env_solver_kv.cc create mode 100644 src/envelope/wrap_kv_envelope_tracker.cc rename src/envelope/{wrap_env_solver_kv.hh => wrap_kv_envelope_tracker.hh} (70%) diff --git a/src/envelope/EnvSolverDanilov.cc b/src/envelope/DanilovEnvelopeTracker.cc similarity index 90% rename from src/envelope/EnvSolverDanilov.cc rename to src/envelope/DanilovEnvelopeTracker.cc index e77390a2..7e9fb341 100644 --- a/src/envelope/EnvSolverDanilov.cc +++ b/src/envelope/DanilovEnvelopeTracker.cc @@ -1,18 +1,18 @@ -#include "EnvSolverDanilov.hh" +#include "DanilovEnvelopeTracker.hh" -EnvSolverDanilov::EnvSolverDanilov(double perveance) : CppPyWrapper(NULL) { +DanilovEnvelopeTracker::DanilovEnvelopeTracker(double perveance) : CppPyWrapper(NULL) { Q = perveance; } -void EnvSolverDanilov::setPerveance(double perveance) { +void DanilovEnvelopeTracker::setPerveance(double perveance) { Q = perveance; } -double EnvSolverDanilov::getPerveance() { +double DanilovEnvelopeTracker::getPerveance() { return Q; } -void EnvSolverDanilov::trackBunch(Bunch *bunch, double length) { +void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { // Compute ellipse size and orientation. double a = bunch->x(0); double b = bunch->x(1); diff --git a/src/envelope/EnvSolverDanilov.hh b/src/envelope/DanilovEnvelopeTracker.hh similarity index 83% rename from src/envelope/EnvSolverDanilov.hh rename to src/envelope/DanilovEnvelopeTracker.hh index 6b28f515..9758931d 100644 --- a/src/envelope/EnvSolverDanilov.hh +++ b/src/envelope/DanilovEnvelopeTracker.hh @@ -1,5 +1,5 @@ -#ifndef ENV_SOLVER_DANILOV_H -#define ENV_SOLVER_DANILOV_H +#ifndef DANILOV_ENVELOPE_TRACKER_H +#define DANILOV_ENVELOPE_TRACKER_H #include "Bunch.hh" #include "CppPyWrapper.hh" @@ -22,9 +22,9 @@ using namespace std; dependent two dimensional and three dimensional space charge distributions with linear force", PPRAB 6, 74–85 (2003). */ -class EnvSolverDanilov : public OrbitUtils::CppPyWrapper { +class DanilovEnvelopeTracker : public OrbitUtils::CppPyWrapper { public: - EnvSolverDanilov(double perveanceQ); + DanilovEnvelopeTracker(double perveanceQ); void trackBunch(Bunch *bunch, double length); void setPerveance(double perveance); double getPerveance(); diff --git a/src/envelope/EnvSolverKV.cc b/src/envelope/KVEnvelopeTracker.cc similarity index 75% rename from src/envelope/EnvSolverKV.cc rename to src/envelope/KVEnvelopeTracker.cc index 39e6b521..43a47022 100644 --- a/src/envelope/EnvSolverKV.cc +++ b/src/envelope/KVEnvelopeTracker.cc @@ -1,36 +1,36 @@ -#include "EnvSolverKV.hh" +#include "KVEnvelopeTracker.hh" -EnvSolverKV::EnvSolverKV(double perveance, double emittance_x, double emittance_y) : CppPyWrapper(NULL) { +KVEnvelopeTracker::KVEnvelopeTracker(double perveance, double emittance_x, double emittance_y) : CppPyWrapper(NULL) { Q = perveance; eps_x = emittance_x; eps_y = emittance_y; } -void EnvSolverKV::setPerveance(double perveance) { +void KVEnvelopeTracker::setPerveance(double perveance) { Q = perveance; } -void EnvSolverKV::setEmittanceX(double emittance) { +void KVEnvelopeTracker::setEmittanceX(double emittance) { eps_x = emittance; } -void EnvSolverKV::setEmittanceY(double emittance) { +void KVEnvelopeTracker::setEmittanceY(double emittance) { eps_y = emittance; } -double EnvSolverKV::getPerveance() { +double KVEnvelopeTracker::getPerveance() { return Q; } -double EnvSolverKV::getEmittanceX() { +double KVEnvelopeTracker::getEmittanceX() { return eps_x; } -double EnvSolverKV::getEmittanceY() { +double KVEnvelopeTracker::getEmittanceY() { return eps_y; } -void EnvSolverKV::trackBunch(Bunch *bunch, double length) { +void KVEnvelopeTracker::trackBunch(Bunch *bunch, double length) { // Track envelope double cx = bunch->x(0); double cy = bunch->y(0); diff --git a/src/envelope/EnvSolverKV.hh b/src/envelope/KVEnvelopeTracker.hh similarity index 80% rename from src/envelope/EnvSolverKV.hh rename to src/envelope/KVEnvelopeTracker.hh index 28f7bccd..c8c28e62 100644 --- a/src/envelope/EnvSolverKV.hh +++ b/src/envelope/KVEnvelopeTracker.hh @@ -1,5 +1,5 @@ -#ifndef ENV_SOLVER_KV_H -#define ENV_SOLVER_KV_H +#ifndef KV_ENVELOPE_TRACKER_H +#define KV_ENVELOPE_TRACKER_H #include "Bunch.hh" #include "CppPyWrapper.hh" @@ -14,9 +14,9 @@ kicks to the other particles in the bunch. This class does not yet handle boudary conditions or dispersion. */ -class EnvSolverKV : public OrbitUtils::CppPyWrapper { +class KVEnvelopeTracker : public OrbitUtils::CppPyWrapper { public: - EnvSolverKV(double perveance, double emittance_x, double emittance_y); + KVEnvelopeTracker(double perveance, double emittance_x, double emittance_y); void trackBunch(Bunch *bunch, double length); void setPerveance(double perveance); void setEmittanceX(double emittance); diff --git a/src/envelope/wrap_danilov_envelope_tracker.cc b/src/envelope/wrap_danilov_envelope_tracker.cc new file mode 100644 index 00000000..bb0c76d5 --- /dev/null +++ b/src/envelope/wrap_danilov_envelope_tracker.cc @@ -0,0 +1,150 @@ +#include + +#include "orbit_mpi.hh" +#include "pyORBIT_Object.hh" + +#include "DanilovEnvelopeTracker.hh" +#include "wrap_bunch.hh" +#include "wrap_envelope.hh" +#include "wrap_danilov_envelope_tracker.hh" + +namespace wrap_envelope { + +#ifdef __cplusplus +extern "C" { +#endif + +// Constructor for Python class wrapping DanilovEnvelopeTracker instance. +// It never will be called directly. +static PyObject *DanilovEnvelopeTracker_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + pyORBIT_Object *self; + self = (pyORBIT_Object *)type->tp_alloc(type, 0); + self->cpp_obj = NULL; + return (PyObject *)self; +} + +// Initialization of Python DanilovEnvelopeTracker class. +// This is implementation of the __init__ method. +static int DanilovEnvelopeTracker_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { + double perveance = 0.0; + self->cpp_obj = new DanilovEnvelopeTracker(perveance); + ((DanilovEnvelopeTracker *)self->cpp_obj)->setPyWrapper((PyObject *)self); + return 0; +} + +// Method: trackBunch(Bunch* bunch, double length) +static PyObject *DanilovEnvelopeTracker_trackBunch(PyObject *self, PyObject *args) { + pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; + PyObject *pyBunch; + double length; + if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { + ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - trackBunch(Bunch* bunch, double length) - parameters are needed."); + } + PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); + if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { + ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); + } + Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; + cpp_DanilovEnvelopeTracker->trackBunch(cpp_bunch, length); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setPerveance(double perveance) +static PyObject *DanilovEnvelopeTracker_setPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; + double perveance; + if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { + ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - setPerveance(double perveance) - parameters are needed."); + } + cpp_DanilovEnvelopeTracker->setPerveance(perveance); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: getPerveance() +static PyObject *DanilovEnvelopeTracker_getPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; + double perveance = cpp_DanilovEnvelopeTracker->getPerveance(); + return Py_BuildValue("d", perveance); +} + +// Destructor for python DanilovEnvelopeTracker class (__del__ method) +static void DanilovEnvelopeTracker_del(pyORBIT_Object *self) { + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)self->cpp_obj; + delete cpp_DanilovEnvelopeTracker; + self->ob_base.ob_type->tp_free((PyObject *)self); +} + +// Definition of Python DanilovEnvelopeTracker wrapper class methods. +// They will be available from the Python level. +static PyMethodDef DanilovEnvelopeTrackerClassMethods[] = { + {"getPerveance", DanilovEnvelopeTracker_getPerveance, METH_VARARGS, "Get space charge perveance."}, + {"setPerveance", DanilovEnvelopeTracker_setPerveance, METH_VARARGS, "Set space charge perveance."}, + {"trackBunch", DanilovEnvelopeTracker_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, + {NULL} +}; + +// Definition of Python DanilovEnvelopeTracker wrapper class members. +// They will be available from the Python level. +static PyMemberDef DanilovEnvelopeTrackerClassMembers[] = { + {NULL}}; + +// New python DanilovEnvelopeTracker wrapper type definition. +static PyTypeObject pyORBIT_DanilovEnvelopeTracker_Type = { + PyVarObject_HEAD_INIT(NULL, 0) "DanilovEnvelopeTracker", /*tp_name*/ + sizeof(pyORBIT_Object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)DanilovEnvelopeTracker_del, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "The DanilovEnvelopeTracker python wrapper", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + DanilovEnvelopeTrackerClassMethods, /* tp_methods */ + DanilovEnvelopeTrackerClassMembers, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)DanilovEnvelopeTracker_init, /* tp_init */ + 0, /* tp_alloc */ + DanilovEnvelopeTracker_new, /* tp_new */ +}; + +// Initialization function of the pyDanilovEnvelopeTracker class +void initDanilovEnvelopeTracker(PyObject *module) { + if (PyType_Ready(&pyORBIT_DanilovEnvelopeTracker_Type) < 0) + return; + Py_INCREF(&pyORBIT_DanilovEnvelopeTracker_Type); + PyModule_AddObject(module, "DanilovEnvelopeTracker", (PyObject *)&pyORBIT_DanilovEnvelopeTracker_Type); +} + +#ifdef __cplusplus +} +#endif + +// end of namespace wrap_envelope +} // namespace wrap_envelope diff --git a/src/envelope/wrap_danilov_envelope_tracker.hh b/src/envelope/wrap_danilov_envelope_tracker.hh new file mode 100644 index 00000000..ae52db5e --- /dev/null +++ b/src/envelope/wrap_danilov_envelope_tracker.hh @@ -0,0 +1,18 @@ +#ifndef WRAP_DANILOV_ENVELOPE_TRACKER_H +#define WRAP_DANILOV_ENVELOPE_TRACKER_H + +#include "Python.h" + +#ifdef __cplusplus +extern "C" { +#endif + +namespace wrap_envelope { +void initDanilovEnvelopeTracker(PyObject *module); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/envelope/wrap_env_solver_danilov.cc b/src/envelope/wrap_env_solver_danilov.cc deleted file mode 100644 index fad0b48e..00000000 --- a/src/envelope/wrap_env_solver_danilov.cc +++ /dev/null @@ -1,150 +0,0 @@ -#include - -#include "orbit_mpi.hh" -#include "pyORBIT_Object.hh" - -#include "EnvSolverDanilov.hh" -#include "wrap_bunch.hh" -#include "wrap_envelope.hh" -#include "wrap_env_solver_danilov.hh" - -namespace wrap_envelope { - -#ifdef __cplusplus -extern "C" { -#endif - -// Constructor for Python class wrapping EnvSolverDanilov instance. -// It never will be called directly. -static PyObject *EnvSolverDanilov_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - pyORBIT_Object *self; - self = (pyORBIT_Object *)type->tp_alloc(type, 0); - self->cpp_obj = NULL; - return (PyObject *)self; -} - -// Initialization of Python EnvSolverDanilov class. -// This is implementation of the __init__ method. -static int EnvSolverDanilov_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { - double perveance = 0.0; - self->cpp_obj = new EnvSolverDanilov(perveance); - ((EnvSolverDanilov *)self->cpp_obj)->setPyWrapper((PyObject *)self); - return 0; -} - -// Method: trackBunch(Bunch* bunch, double length) -static PyObject *EnvSolverDanilov_trackBunch(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverDanilov = (pyORBIT_Object *)self; - EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)pyEnvSolverDanilov->cpp_obj; - PyObject *pyBunch; - double length; - if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { - ORBIT_MPI_Finalize("PyEnvSolverDanilov - trackBunch(Bunch* bunch, double length) - parameters are needed."); - } - PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); - if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { - ORBIT_MPI_Finalize("PyEnvSolverDanilov - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); - } - Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; - cpp_EnvSolverDanilov->trackBunch(cpp_bunch, length); - Py_INCREF(Py_None); - return Py_None; -} - -// Method: setPerveance(double perveance) -static PyObject *EnvSolverDanilov_setPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverDanilov = (pyORBIT_Object *)self; - EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)pyEnvSolverDanilov->cpp_obj; - double perveance; - if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { - ORBIT_MPI_Finalize("PyEnvSolverDanilov - setPerveance(double perveance) - parameters are needed."); - } - cpp_EnvSolverDanilov->setPerveance(perveance); - Py_INCREF(Py_None); - return Py_None; -} - -// Method: getPerveance() -static PyObject *EnvSolverDanilov_getPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverDanilov = (pyORBIT_Object *)self; - EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)pyEnvSolverDanilov->cpp_obj; - double perveance = cpp_EnvSolverDanilov->getPerveance(); - return Py_BuildValue("d", perveance); -} - -// Destructor for python EnvSolverDanilov class (__del__ method) -static void EnvSolverDanilov_del(pyORBIT_Object *self) { - EnvSolverDanilov *cpp_EnvSolverDanilov = (EnvSolverDanilov *)self->cpp_obj; - delete cpp_EnvSolverDanilov; - self->ob_base.ob_type->tp_free((PyObject *)self); -} - -// Definition of Python EnvSolverDanilov wrapper class methods. -// They will be available from the Python level. -static PyMethodDef EnvSolverDanilovClassMethods[] = { - {"getPerveance", EnvSolverDanilov_getPerveance, METH_VARARGS, "Get space charge perveance."}, - {"setPerveance", EnvSolverDanilov_setPerveance, METH_VARARGS, "Set space charge perveance."}, - {"trackBunch", EnvSolverDanilov_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, - {NULL} -}; - -// Definition of Python EnvSolverDanilov wrapper class members. -// They will be available from the Python level. -static PyMemberDef EnvSolverDanilovClassMembers[] = { - {NULL}}; - -// New python EnvSolverDanilov wrapper type definition. -static PyTypeObject pyORBIT_EnvSolverDanilov_Type = { - PyVarObject_HEAD_INIT(NULL, 0) "EnvSolverDanilov", /*tp_name*/ - sizeof(pyORBIT_Object), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)EnvSolverDanilov_del, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash */ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ - "The EnvSolverDanilov python wrapper", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - EnvSolverDanilovClassMethods, /* tp_methods */ - EnvSolverDanilovClassMembers, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)EnvSolverDanilov_init, /* tp_init */ - 0, /* tp_alloc */ - EnvSolverDanilov_new, /* tp_new */ -}; - -// Initialization function of the pyEnvSolverDanilov class -void initEnvSolverDanilov(PyObject *module) { - if (PyType_Ready(&pyORBIT_EnvSolverDanilov_Type) < 0) - return; - Py_INCREF(&pyORBIT_EnvSolverDanilov_Type); - PyModule_AddObject(module, "EnvSolverDanilov", (PyObject *)&pyORBIT_EnvSolverDanilov_Type); -} - -#ifdef __cplusplus -} -#endif - -// end of namespace wrap_envelope -} // namespace wrap_envelope diff --git a/src/envelope/wrap_env_solver_danilov.hh b/src/envelope/wrap_env_solver_danilov.hh deleted file mode 100644 index 4167e72a..00000000 --- a/src/envelope/wrap_env_solver_danilov.hh +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef WRAP_ENV_SOLVER_DANILOV_H -#define WRAP_ENV_SOLVER_DANILOV_H - -#include "Python.h" - -#ifdef __cplusplus -extern "C" { -#endif - -namespace wrap_envelope { -void initEnvSolverDanilov(PyObject *module); -} - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/src/envelope/wrap_env_solver_kv.cc b/src/envelope/wrap_env_solver_kv.cc deleted file mode 100644 index 18f8af73..00000000 --- a/src/envelope/wrap_env_solver_kv.cc +++ /dev/null @@ -1,198 +0,0 @@ -#include - -#include "orbit_mpi.hh" -#include "pyORBIT_Object.hh" - -#include "EnvSolverKV.hh" -#include "wrap_bunch.hh" -#include "wrap_envelope.hh" -#include "wrap_env_solver_kv.hh" - -namespace wrap_envelope { - -#ifdef __cplusplus -extern "C" { -#endif - -// Constructor for Python class wrapping EnvSolverKV instance. -// It never will be called directly. -static PyObject *EnvSolverKV_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - pyORBIT_Object *self; - self = (pyORBIT_Object *)type->tp_alloc(type, 0); - self->cpp_obj = NULL; - return (PyObject *)self; -} - -// Initialization of Python EnvSolverKV class. -// This is implementation of the __init__ method. -static int EnvSolverKV_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { - double perveance = 0.0; - double eps_x = 1.0; - double eps_y = 1.0; - self->cpp_obj = new EnvSolverKV(perveance, eps_x, eps_y); - ((EnvSolverKV *)self->cpp_obj)->setPyWrapper((PyObject *)self); - return 0; -} - -// Method: trackBunch(Bunch* bunch, double length) -static PyObject *EnvSolverKV_trackBunch(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - PyObject *pyBunch; - double length; - if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { - ORBIT_MPI_Finalize("PyEnvSolverKV - trackBunch(Bunch* bunch, double length) - parameters are needed."); - } - PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); - if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { - ORBIT_MPI_Finalize("PyEnvSolverKV - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); - } - Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; - cpp_EnvSolverKV->trackBunch(cpp_bunch, length); - Py_INCREF(Py_None); - return Py_None; -} - -// Method: setPerveance(double perveance) -static PyObject *EnvSolverKV_setPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - double perveance; - if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { - ORBIT_MPI_Finalize("PyEnvSolverKV - setPerveance(double perveance) - parameters are needed."); - } - cpp_EnvSolverKV->setPerveance(perveance); - Py_INCREF(Py_None); - return Py_None; -} - -// Method: setEmittanceX(double emittance_x) -static PyObject *EnvSolverKV_setEmittanceX(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - double emittance_x; - if (!PyArg_ParseTuple(args, "d:setEmittanceX", &emittance_x)) { - ORBIT_MPI_Finalize("PyEnvSolverKV - setEmittanceX(double emittance_x) - parameters are needed."); - } - cpp_EnvSolverKV->setEmittanceX(emittance_x); - Py_INCREF(Py_None); - return Py_None; -} - -// Method: setEmittanceY(double emittance_y) -static PyObject *EnvSolverKV_setEmittanceY(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - double emittance_y; - if (!PyArg_ParseTuple(args, "d:setEmittanceY", &emittance_y)) { - ORBIT_MPI_Finalize("PyEnvSolverKV - setEmittanceY(double emittance_y) - parameters are needed."); - } - cpp_EnvSolverKV->setEmittanceY(emittance_y); - Py_INCREF(Py_None); - return Py_None; -} - -// Method: getPerveance() -static PyObject *EnvSolverKV_getPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - double perveance = cpp_EnvSolverKV->getPerveance(); - return Py_BuildValue("d", perveance); -} - -// Method: getEmittanceX() -static PyObject *EnvSolverKV_getEmittanceX(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - double eps_x = cpp_EnvSolverKV->getEmittanceX(); - return Py_BuildValue("d", eps_x); -} - -// Method: getEmittanceY() -static PyObject *EnvSolverKV_getEmittanceY(PyObject *self, PyObject *args) { - pyORBIT_Object *pyEnvSolverKV = (pyORBIT_Object *)self; - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)pyEnvSolverKV->cpp_obj; - double eps_y = cpp_EnvSolverKV->getEmittanceY(); - return Py_BuildValue("d", eps_y); -} - -// Destructor for python EnvSolverKV class (__del__ method) -static void EnvSolverKV_del(pyORBIT_Object *self) { - EnvSolverKV *cpp_EnvSolverKV = (EnvSolverKV *)self->cpp_obj; - delete cpp_EnvSolverKV; - self->ob_base.ob_type->tp_free((PyObject *)self); -} - -// Definition of Python EnvSolverKV wrapper class methods. -// They will be available from the Python level. -static PyMethodDef EnvSolverKVClassMethods[] = { - {"getEmittanceX", EnvSolverKV_getEmittanceX, METH_VARARGS, "Get emittance (x)."}, - {"getEmittanceY", EnvSolverKV_getEmittanceY, METH_VARARGS, "Get emittance (y)."}, - {"getPerveance", EnvSolverKV_getPerveance, METH_VARARGS, "Get space charge perveance."}, - {"setEmittanceX", EnvSolverKV_setEmittanceX, METH_VARARGS, "Set emittance (x)."}, - {"setEmittanceY", EnvSolverKV_setEmittanceY, METH_VARARGS, "Set emittance (y)."}, - {"setPerveance", EnvSolverKV_setPerveance, METH_VARARGS, "Set space charge perveance."}, - {"trackBunch", EnvSolverKV_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, - {NULL} -}; - -// Definition of Python EnvSolverKV wrapper class members. -// They will be available from the Python level. -static PyMemberDef EnvSolverKVClassMembers[] = { - {NULL}}; - -// New python EnvSolverKV wrapper type definition. -static PyTypeObject pyORBIT_EnvSolverKV_Type = { - PyVarObject_HEAD_INIT(NULL, 0) "EnvSolverKV", /*tp_name*/ - sizeof(pyORBIT_Object), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)EnvSolverKV_del, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash */ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ - "The EnvSolverKV python wrapper", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - EnvSolverKVClassMethods, /* tp_methods */ - EnvSolverKVClassMembers, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)EnvSolverKV_init, /* tp_init */ - 0, /* tp_alloc */ - EnvSolverKV_new, /* tp_new */ -}; - -// Initialization function of the pyEnvSolverKV class -void initEnvSolverKV(PyObject *module) { - if (PyType_Ready(&pyORBIT_EnvSolverKV_Type) < 0) - return; - Py_INCREF(&pyORBIT_EnvSolverKV_Type); - PyModule_AddObject(module, "EnvSolverKV", (PyObject *)&pyORBIT_EnvSolverKV_Type); -} - -#ifdef __cplusplus -} -#endif - -// end of namespace wrap_envelope -} // namespace wrap_envelope diff --git a/src/envelope/wrap_envelope.cc b/src/envelope/wrap_envelope.cc index 0394f59f..4d95ac57 100644 --- a/src/envelope/wrap_envelope.cc +++ b/src/envelope/wrap_envelope.cc @@ -5,8 +5,8 @@ #include "wrap_bunch.hh" #include "wrap_envelope.hh" -#include "wrap_env_solver_kv.hh" -#include "wrap_env_solver_danilov.hh" +#include "wrap_kv_envelope_tracker.hh" +#include "wrap_danilov_envelope_tracker.hh" namespace wrap_envelope { @@ -26,8 +26,8 @@ static struct PyModuleDef cModPyDem = { PyMODINIT_FUNC initenvelope() { PyObject *module = PyModule_Create(&cModPyDem); - wrap_envelope::initEnvSolverKV(module); - wrap_envelope::initEnvSolverDanilov(module); + wrap_envelope::initKVEnvelopeTracker(module); + wrap_envelope::initDanilovEnvelopeTracker(module); return module; } diff --git a/src/envelope/wrap_kv_envelope_tracker.cc b/src/envelope/wrap_kv_envelope_tracker.cc new file mode 100644 index 00000000..64354d63 --- /dev/null +++ b/src/envelope/wrap_kv_envelope_tracker.cc @@ -0,0 +1,198 @@ +#include + +#include "orbit_mpi.hh" +#include "pyORBIT_Object.hh" + +#include "KVEnvelopeTracker.hh" +#include "wrap_bunch.hh" +#include "wrap_envelope.hh" +#include "wrap_kv_envelope_tracker.hh" + +namespace wrap_envelope { + +#ifdef __cplusplus +extern "C" { +#endif + +// Constructor for Python class wrapping KVEnvelopeTracker instance. +// It never will be called directly. +static PyObject *KVEnvelopeTracker_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + pyORBIT_Object *self; + self = (pyORBIT_Object *)type->tp_alloc(type, 0); + self->cpp_obj = NULL; + return (PyObject *)self; +} + +// Initialization of Python KVEnvelopeTracker class. +// This is implementation of the __init__ method. +static int KVEnvelopeTracker_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { + double perveance = 0.0; + double eps_x = 1.0; + double eps_y = 1.0; + self->cpp_obj = new KVEnvelopeTracker(perveance, eps_x, eps_y); + ((KVEnvelopeTracker *)self->cpp_obj)->setPyWrapper((PyObject *)self); + return 0; +} + +// Method: trackBunch(Bunch* bunch, double length) +static PyObject *KVEnvelopeTracker_trackBunch(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + PyObject *pyBunch; + double length; + if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - trackBunch(Bunch* bunch, double length) - parameters are needed."); + } + PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); + if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); + } + Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; + cpp_KVEnvelopeTracker->trackBunch(cpp_bunch, length); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setPerveance(double perveance) +static PyObject *KVEnvelopeTracker_setPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double perveance; + if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setPerveance(double perveance) - parameters are needed."); + } + cpp_KVEnvelopeTracker->setPerveance(perveance); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setEmittanceX(double emittance_x) +static PyObject *KVEnvelopeTracker_setEmittanceX(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double emittance_x; + if (!PyArg_ParseTuple(args, "d:setEmittanceX", &emittance_x)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setEmittanceX(double emittance_x) - parameters are needed."); + } + cpp_KVEnvelopeTracker->setEmittanceX(emittance_x); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: setEmittanceY(double emittance_y) +static PyObject *KVEnvelopeTracker_setEmittanceY(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double emittance_y; + if (!PyArg_ParseTuple(args, "d:setEmittanceY", &emittance_y)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setEmittanceY(double emittance_y) - parameters are needed."); + } + cpp_KVEnvelopeTracker->setEmittanceY(emittance_y); + Py_INCREF(Py_None); + return Py_None; +} + +// Method: getPerveance() +static PyObject *KVEnvelopeTracker_getPerveance(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double perveance = cpp_KVEnvelopeTracker->getPerveance(); + return Py_BuildValue("d", perveance); +} + +// Method: getEmittanceX() +static PyObject *KVEnvelopeTracker_getEmittanceX(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double eps_x = cpp_KVEnvelopeTracker->getEmittanceX(); + return Py_BuildValue("d", eps_x); +} + +// Method: getEmittanceY() +static PyObject *KVEnvelopeTracker_getEmittanceY(PyObject *self, PyObject *args) { + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double eps_y = cpp_KVEnvelopeTracker->getEmittanceY(); + return Py_BuildValue("d", eps_y); +} + +// Destructor for python KVEnvelopeTracker class (__del__ method) +static void KVEnvelopeTracker_del(pyORBIT_Object *self) { + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)self->cpp_obj; + delete cpp_KVEnvelopeTracker; + self->ob_base.ob_type->tp_free((PyObject *)self); +} + +// Definition of Python KVEnvelopeTracker wrapper class methods. +// They will be available from the Python level. +static PyMethodDef KVEnvelopeTrackerClassMethods[] = { + {"getEmittanceX", KVEnvelopeTracker_getEmittanceX, METH_VARARGS, "Get emittance (x)."}, + {"getEmittanceY", KVEnvelopeTracker_getEmittanceY, METH_VARARGS, "Get emittance (y)."}, + {"getPerveance", KVEnvelopeTracker_getPerveance, METH_VARARGS, "Get space charge perveance."}, + {"setEmittanceX", KVEnvelopeTracker_setEmittanceX, METH_VARARGS, "Set emittance (x)."}, + {"setEmittanceY", KVEnvelopeTracker_setEmittanceY, METH_VARARGS, "Set emittance (y)."}, + {"setPerveance", KVEnvelopeTracker_setPerveance, METH_VARARGS, "Set space charge perveance."}, + {"trackBunch", KVEnvelopeTracker_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, + {NULL} +}; + +// Definition of Python KVEnvelopeTracker wrapper class members. +// They will be available from the Python level. +static PyMemberDef KVEnvelopeTrackerClassMembers[] = { + {NULL}}; + +// New python KVEnvelopeTracker wrapper type definition. +static PyTypeObject pyORBIT_KVEnvelopeTracker_Type = { + PyVarObject_HEAD_INIT(NULL, 0) "KVEnvelopeTracker", /*tp_name*/ + sizeof(pyORBIT_Object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)KVEnvelopeTracker_del, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "The KVEnvelopeTracker python wrapper", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + KVEnvelopeTrackerClassMethods, /* tp_methods */ + KVEnvelopeTrackerClassMembers, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)KVEnvelopeTracker_init, /* tp_init */ + 0, /* tp_alloc */ + KVEnvelopeTracker_new, /* tp_new */ +}; + +// Initialization function of the pyKVEnvelopeTracker class +void initKVEnvelopeTracker(PyObject *module) { + if (PyType_Ready(&pyORBIT_KVEnvelopeTracker_Type) < 0) + return; + Py_INCREF(&pyORBIT_KVEnvelopeTracker_Type); + PyModule_AddObject(module, "KVEnvelopeTracker", (PyObject *)&pyORBIT_KVEnvelopeTracker_Type); +} + +#ifdef __cplusplus +} +#endif + +// end of namespace wrap_envelope +} // namespace wrap_envelope diff --git a/src/envelope/wrap_env_solver_kv.hh b/src/envelope/wrap_kv_envelope_tracker.hh similarity index 70% rename from src/envelope/wrap_env_solver_kv.hh rename to src/envelope/wrap_kv_envelope_tracker.hh index 8c3b5a74..fb6fa476 100644 --- a/src/envelope/wrap_env_solver_kv.hh +++ b/src/envelope/wrap_kv_envelope_tracker.hh @@ -1,5 +1,5 @@ -#ifndef WRAP_ENV_SOLVER_KV_H -#define WRAP_ENV_SOLVER_KV_H +#ifndef WRAP_KV_ENVELOPE_TRACKER_H +#define WRAP_KV_ENVELOPE_TRACKER_H #include "Python.h" From 9c809102ea8d429798cd525472971f65c5a3de91 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:38:32 -0400 Subject: [PATCH 14/34] Fix name --- src/envelope/wrap_kv_envelope_tracker.hh | 2 +- src/meson.build | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/envelope/wrap_kv_envelope_tracker.hh b/src/envelope/wrap_kv_envelope_tracker.hh index fb6fa476..be2b0112 100644 --- a/src/envelope/wrap_kv_envelope_tracker.hh +++ b/src/envelope/wrap_kv_envelope_tracker.hh @@ -8,7 +8,7 @@ extern "C" { #endif namespace wrap_envelope { -void initEnvSolverKV(PyObject *module); +void initKVEnvelopeSolver(PyObject *module); } #ifdef __cplusplus diff --git a/src/meson.build b/src/meson.build index 78528763..2242ea83 100644 --- a/src/meson.build +++ b/src/meson.build @@ -247,10 +247,10 @@ sources = files([ 'teapot/wrap_matrix_generator.cc', 'teapot/teapotbase.cc', 'teapot/MatrixGenerator.cc', - 'envelope/EnvSolverKV.cc', - 'envelope/EnvSolverDanilov.cc', - 'envelope/wrap_env_solver_kv.cc', - 'envelope/wrap_env_solver_danilov.cc', + 'envelope/KVEnvelopeTracker.cc', + 'envelope/DanilovEnvelopeTracker.cc', + 'envelope/wrap_kv_envelope_tracker.cc', + 'envelope/wrap_danilov_envelope_tracker.cc', 'envelope/wrap_envelope.cc', ]) inc = include_directories([ From 52dd0e896c0ad471dc325cf0e5c5339f64a58fe3 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:41:47 -0400 Subject: [PATCH 15/34] C++ additions complete --- src/envelope/wrap_kv_envelope_tracker.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/envelope/wrap_kv_envelope_tracker.hh b/src/envelope/wrap_kv_envelope_tracker.hh index be2b0112..2c505d72 100644 --- a/src/envelope/wrap_kv_envelope_tracker.hh +++ b/src/envelope/wrap_kv_envelope_tracker.hh @@ -8,7 +8,7 @@ extern "C" { #endif namespace wrap_envelope { -void initKVEnvelopeSolver(PyObject *module); +void initKVEnvelopeTracker(PyObject *module); } #ifdef __cplusplus From 9803e8e26ab92e6941d7e70393e7a16a97bac504 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:43:35 -0400 Subject: [PATCH 16/34] Add envelope python module --- py/orbit/envelope/__init__.py | 0 py/orbit/meson.build | 1 + 2 files changed, 1 insertion(+) create mode 100644 py/orbit/envelope/__init__.py diff --git a/py/orbit/envelope/__init__.py b/py/orbit/envelope/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/py/orbit/meson.build b/py/orbit/meson.build index 2ba16e73..651b14d5 100644 --- a/py/orbit/meson.build +++ b/py/orbit/meson.build @@ -24,6 +24,7 @@ subdir('space_charge') subdir('errors') subdir('matrix_lattice') subdir('teapot') +subdir('envelope') py_sources = files([ From 19c1695fe27aeff744ba3122a442a654ba512c31 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 17:48:47 -0400 Subject: [PATCH 17/34] Add utils.py to envelope module --- py/orbit/envelope/utils.py | 91 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 py/orbit/envelope/utils.py diff --git a/py/orbit/envelope/utils.py b/py/orbit/envelope/utils.py new file mode 100644 index 00000000..d9638d81 --- /dev/null +++ b/py/orbit/envelope/utils.py @@ -0,0 +1,91 @@ +import numpy as np + +from orbit.core.bunch import Bunch +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.teapot import TEAPOT_Lattice +from orbit.teapot import TEAPOT_MATRIX_Lattice + + +def build_rotation_matrix(angle: float) -> np.ndarray: + c, s = np.cos(angle), np.sin(angle) + return np.array([[c, s], [-s, c]]) + + +def build_rotation_matrix_xy(angle: float) -> np.ndarray: + c, s = np.cos(angle), np.sin(angle) + return np.array([[c, 0, s, 0], [0, c, 0, s], [-s, 0, c, 0], [0, -s, 0, c]]) + + +def build_phase_advance_matrix(*phase_advances: list[float]) -> np.ndarray: + n = len(phase_advances) + M = np.zeros((2 * n, 2 * n)) + for i, phase_advance in enumerate(phase_advances): + i = i * 2 + M[i : i + 2, i : i + 2] = build_rotation_matrix(phase_advance) + return M + + +def get_transfer_matrix(lattice: AccLattice, bunch: Bunch) -> np.ndarray: + matrix_lattice = TEAPOT_MATRIX_Lattice(lattice, bunch) + M = np.zeros((4, 4)) + for i in range(4): + for j in range(4): + M[i, j] = matrix_lattice.oneTurnMatrix.get(i, j) + return M + + +def fit_transfer_matrix(lattice: AccLattice, bunch: Bunch) -> np.ndarray: + step_arr_init = np.full(4, 1.00e-06) + step_arr = np.copy(step_arr_init) + step_reduce = 20.0 + + _bunch = Bunch() + bunch.copyEmptyBunchTo(_bunch) + + _bunch.addParticle(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) + _bunch.addParticle(step_arr[0] / step_reduce, 0.0, 0.0, 0.0, 0.0, 0.0) + _bunch.addParticle(0.0, step_arr[1] / step_reduce, 0.0, 0.0, 0.0, 0.0) + _bunch.addParticle(0.0, 0.0, step_arr[2] / step_reduce, 0.0, 0.0, 0.0) + _bunch.addParticle(0.0, 0.0, 0.0, step_arr[3] / step_reduce, 0.0, 0.0) + _bunch.addParticle(step_arr[0], 0.0, 0.0, 0.0, 0.0, 0.0) + _bunch.addParticle(0.0, step_arr[1], 0.0, 0.0, 0.0, 0.0) + _bunch.addParticle(0.0, 0.0, step_arr[2], 0.0, 0.0, 0.0) + _bunch.addParticle(0.0, 0.0, 0.0, step_arr[3], 0.0, 0.0) + + lattice.trackBunch(_bunch) + + X = get_bunch_coords(bunch) + X = X[:, (0, 2, 3, 4)] + + M = np.zeros((4, 4)) + for i in range(4): + for j in range(4): + x1 = step_arr[i] / step_reduce + x2 = step_arr[i] + y0 = X[0, j] + y1 = X[i + 1, j] + y2 = X[i + 1 + 4, j] + M[j, i] = ((y1 - y0) * x2 * x2 - (y2 - y0) * x1 * x1) / (x1 * x2 * (x2 - x1)) + return M + + +def get_perveance(mass: float, kin_energy: float, line_density: float) -> float: + classical_proton_radius = 1.53469e-18 # [m] + gamma = 1.0 + (kin_energy / mass) # Lorentz factor + beta = np.sqrt(1.0 - (1.0 / gamma) ** 2) # velocity/speed_of_light + return (2.0 * classical_proton_radius * line_density) / (beta**2 * gamma**3) + + +def calc_cov_twiss_2d(cov_matrix: np.ndarray) -> tuple[float, float, float]: + emittance = np.sqrt(np.linalg.det(cov_matrix)) + alpha = -cov_matrix[0, 1] / emittance + beta = cov_matrix[0, 0] / emittance + return (alpha, beta, emittance) + + +def bunch_to_numpy(bunch: Bunch) -> np.ndarray: + x = np.zeros((bunch.getSize(), 6)) + for i in range(bunch.getSize()): + x[i, :] = [bunch.x(i), bunch.xp(i), bunch.y(i), bunch.yp(i), bunch.z(i), bunch.dE(i)] + return x \ No newline at end of file From f345bb248f1b7bb1055df2a62e35b83d94350c0f Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 19:50:34 -0400 Subject: [PATCH 18/34] Add KVEnvelope class --- py/orbit/envelope/__init__.py | 11 + py/orbit/envelope/danilov.py | 0 py/orbit/envelope/kv.py | 441 +++++++++++++++++++++ py/orbit/envelope/lattice_modifications.py | 129 ++++++ py/orbit/envelope/meson.build | 14 + py/orbit/envelope/nodes.py | 65 +++ py/orbit/envelope/utils.py | 8 +- 7 files changed, 667 insertions(+), 1 deletion(-) create mode 100644 py/orbit/envelope/danilov.py create mode 100644 py/orbit/envelope/kv.py create mode 100644 py/orbit/envelope/lattice_modifications.py create mode 100644 py/orbit/envelope/meson.build create mode 100644 py/orbit/envelope/nodes.py diff --git a/py/orbit/envelope/__init__.py b/py/orbit/envelope/__init__.py index e69de29b..fde0f76f 100644 --- a/py/orbit/envelope/__init__.py +++ b/py/orbit/envelope/__init__.py @@ -0,0 +1,11 @@ +from .nodes import EnvelopeTrackerNode +from .nodes import KVEnvelopeTrackerNode +from .nodes import DanilovEnvelopeTrackerNode +from .lattice_modifications import add_kv_envelope_tracker_nodes +from .lattice_modifications import add_danilov_envelope_tracker_nodes +from .kv import KVEnvelope +from .kv import KVEnvelopeMonitor +from .kv import KVEnvelopeTracker +# from .danilov import DanilovEnvelope +# from .danilov import DanilovEnvelopeMonitor +# from .danilov import DanilovEnvelopeTracker diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py new file mode 100644 index 00000000..e69de29b diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py new file mode 100644 index 00000000..1552f5d9 --- /dev/null +++ b/py/orbit/envelope/kv.py @@ -0,0 +1,441 @@ +"""Envelope model for upright KV distribution.""" + +import copy +import math +import time +from typing import Callable +from typing import Iterable +#from typing import Self + +import numpy as np +import scipy.optimize +from tqdm import tqdm + +from orbit.core.bunch import Bunch + +from ..lattice import AccActionsContainer +from ..lattice import AccLattice +from ..lattice import AccNode +from ..teapot import TEAPOT_Lattice +from ..teapot import TEAPOT_MATRIX_Lattice +from ..utils import consts + +from .nodes import KVEnvelopeTrackerNode +from .lattice_modifications import add_kv_envelope_tracker_nodes +from .utils import calc_cov_twiss +from .utils import bunch_to_numpy +from .utils import get_perveance +from .utils import get_transfer_matrix +from .utils import fit_transfer_matrix +from .utils import build_norm_matrix_from_twiss_2d + + +class KVEnvelope: + """Models KV distribution. + + Attributes + ---------- + params: ndarray, shape(4,) + The envelope parameters [cx, cx', cy, cy']. The cx and cy parameters + represent the envelope extent along the x and y axis; cx' and cy' are + their derivatives with respect to the distance x. + eps_x: float + The rms emittance of the x-x' distribution: sqrt( - ). + eps_y: float + The rms emittance of the y-y' distribution: sqrt( - ). + mass: float + Particle [GeV/c^2]. + kin_energy: float + Particle kinetic energy [GeV]. + intensity: float + Bunch intensity (number of particles). + length: float + Bunch length [m]. + perveance: float + Dimensionless beam perveance. + """ + def __init__( + self, + eps_x: float, + eps_y: float, + mass: float, + kin_energy: float, + length: float, + intensity: int, + params: Iterable[float] = None, + ) -> None: + self.eps_x = eps_x + self.eps_y = eps_y + self.mass = mass + self.kin_energy = kin_energy + + self.length = length + self.line_density = None + self.perveance = None + self.set_intensity(intensity) + + self.params = params + if self.params is None: + cx = 2.0 * np.sqrt(self.eps_x * 4.0) + cy = 2.0 * np.sqrt(self.eps_y * 4.0) + self.params = [cx, 0.0, cy, 0.0] + self.params = np.array(self.params) + + def set_intensity(self, intensity: int) -> None: + self.intensity = intensity + self.line_density = intensity / self.length + self.perveance = get_perveance(self.mass, self.kin_energy, self.line_density) + + def set_length(self, length: float) -> None: + self.length = length + self.set_intensity(self.intensity) + + def set_params(self, params: np.ndarray) -> None: + self.params = np.copy(params) + + def copy(self): + return copy.deepcopy(self) + + def cov(self) -> np.ndarray: + """Return covariance matrix. + + See Table II here: https://journals.aps.org/prab/abstract/10.1103/PhysRevSTAB.7.024801 + """ + (cx, cxp, cy, cyp) = self.params + cov_matrix = np.zeros((4, 4)) + cov_matrix[0, 0] = 0.25 * cx**2 + cov_matrix[2, 2] = 0.25 * cy**2 + cov_matrix[1, 1] = 0.25 * cxp**2 + 4.0 * (self.eps_x / cx) ** 2 + cov_matrix[3, 3] = 0.25 * cyp**2 + 4.0 * (self.eps_y / cy) ** 2 + cov_matrix[0, 1] = cov_matrix[1, 0] = 0.25 * cx * cxp + cov_matrix[2, 3] = cov_matrix[3, 2] = 0.25 * cy * cyp + return cov_matrix + + def set_cov(self, cov_matrix: np.ndarray) -> None: + self.eps_x = np.sqrt(np.linalg.det(cov_matrix[0:2, 0:2])) + self.eps_y = np.sqrt(np.linalg.det(cov_matrix[2:4, 2:4])) + cx = np.sqrt(4.0 * cov_matrix[0, 0]) + cy = np.sqrt(4.0 * cov_matrix[2, 2]) + cxp = 2.0 * cov_matrix[0, 1] / np.sqrt(cov_matrix[0, 0]) + cyp = 2.0 * cov_matrix[2, 3] / np.sqrt(cov_matrix[2, 2]) + self.set_params([cx, cxp, cy, cyp]) + + def twiss(self) -> dict[str, float]: + cov_matrix = self.cov() + alpha_x, beta_x, emittance_x = calc_cov_twiss(cov_matrix[0:2, 0:2]) + alpha_y, beta_y, emittance_y = calc_cov_twiss(cov_matrix[2:4, 2:4]) + + params = {} + params["alpha_x"] = alpha_x + params["alpha_y"] = alpha_y + params["beta_x"] = beta_x + params["beta_y"] = beta_y + params["emittance_x"] = emittance_x + params["emittance_y"] = emittance_y + return params + + def set_twiss( + self, + alpha_x: float = None, + beta_x: float = None, + alpha_y: float = None, + beta_y: float = None, + ) -> None: + twiss_params = self.twiss() + if alpha_x is None: + alpha_x = twiss_params["alpha_x"] + if alpha_y is None: + alpha_y = twiss_params["alpha_y"] + if beta_x is None: + beta_x = twiss_params["beta_x"] + if beta_y is None: + beta_y = twiss_params["beta_y"] + + gamma_x = (1.0 + alpha_x**2) / beta_x + gamma_y = (1.0 + alpha_y**2) / beta_y + cov_matrix = np.zeros((4, 4)) + cov_matrix[0, 0] = beta_x * self.eps_x + cov_matrix[2, 2] = beta_y * self.eps_y + cov_matrix[1, 1] = gamma_x * self.eps_x + cov_matrix[3, 3] = gamma_y * self.eps_y + cov_matrix[0, 1] = cov_matrix[1, 0] = -alpha_x * self.eps_x + cov_matrix[2, 3] = cov_matrix[3, 2] = -alpha_y * self.eps_y + self.set_cov(cov_matrix) + + def sample(self, size: int) -> np.ndarray: + twiss_params = self.twiss() + + alpha_x = twiss_params["alpha_x"] + alpha_y = twiss_params["alpha_y"] + beta_x = twiss_params["beta_x"] + beta_y = twiss_params["beta_y"] + eps_x = twiss_params["emittance_x"] + eps_y = twiss_params["emittance_y"] + + V_inv = np.identity(4) + V_inv[0:2, 0:2] = build_norm_matrix_from_twiss_2d(alpha_x, beta_x) + V_inv[2:4, 2:4] = build_norm_matrix_from_twiss_2d(alpha_y, beta_y) + V = np.linalg.inv(V_inv) + + A = np.sqrt(np.diag([eps_x, eps_x, eps_y, eps_y])) + + particles = np.random.normal(size=(size, 4)) + particles = np.matmul(particles, A.T) + particles = np.matmul(particles, V.T) + + particles_full = np.zeros((size, 6)) + particles_full[:, :4] = particles + particles_full[:, 4] = self.length * np.random.uniform(-0.5, 0.5, size=size) + return particles_full + + def from_bunch(self, bunch: Bunch) -> np.ndarray: + """Set envelope parameters from Bunch.""" + self.params = np.zeros(4) + self.params[0] = bunch.x(0) + self.params[1] = bunch.xp(0) + self.params[2] = bunch.y(0) + self.params[3] = bunch.yp(0) + return self.params + + def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: + """Create Bunch object from envelope parameters. + + Parameters + ---------- + size : int + Number of macroparticles in the bunch. These are the number of "test" + particles not counting the first particle, which stores the envelope + parameters. + env : bool + If False, do not store the envelope parameters as the first particle. + + Returns + ------- + Bunch + """ + bunch = Bunch() + bunch.mass(self.mass) + bunch.getSyncParticle().kinEnergy(self.kin_energy) + + if env: + (cx, cxp, cy, cyp) = self.params + bunch.addParticle(cx, cxp, cy, cyp, 0.0, 0.0) + + if size: + samples = self.sample(size) + for i in range(size): + bunch.addParticle(*samples[i]) + + macrosize = self.intensity / size + if self.intensity == 0.0: + macrosize = 1.0 + bunch.macroSize(macrosize) + + return bunch + + +class KVEnvelopeMonitor: + def __init__(self, verbose: int = 0) -> None: + self.verbose = verbose + self.distance = 0.0 + self._pos_old = 0.0 + self._pos_new = 0.0 + + self.history = {} + for key in [ + "s", + "xrms", + "yrms", + ]: + self.history[key] = [] + + def package(self) -> None: + history = copy.deepcopy(self.history) + for key in history: + history[key] = np.array(history[key]) + history["s"] -= history["s"][0] + return history + + def __call__(self, params_dict: dict) -> None: + bunch = params_dict["bunch"] + node = params_dict["node"] + + self._pos_new = params_dict["path_length"] + if self._pos_old > self._pos_new: + self._pos_old = 0.0 + self.distance += self._pos_new - self._pos_old + self._pos_old = self._pos_new + + x_rms = bunch.x(0) * 0.5 + y_rms = bunch.y(0) * 0.5 + + self.history["s"].append(self.distance) + self.history["xrms"].append(x_rms) + self.history["yrms"].append(y_rms) + + if self.verbose: + print("s={:0.3f} x_rms={:0.2f}, y_rms={:0.2f}".format(self.distance, x_rms, y_rms)) + + +class KVEnvelopeTracker: + def __init__(self, lattice: AccLattice, path_length_max: float = None) -> None: + self.lattice = lattice + self.nodes = self.add_nodes( + path_length_min=1.00e-06, + path_length_max=path_length_max, + ) + + # Lower bounds on envelope parameters + self.lb = np.zeros(4) + self.lb[0] = +1.00 - 12 + self.lb[1] = -np.inf + self.lb[2] = +1.00e-12 + self.lb[3] = -np.inf + + # Upper bounds on envelope parameters + self.ub = np.zeros(4) + self.ub[0] = np.inf + self.ub[1] = np.inf + self.ub[2] = np.inf + self.ub[3] = np.inf + + def add_nodes( + self, + path_length_min: float, + path_length_max: float, + ) -> list[KVEnvelopeTrackerNode]: + + self.nodes = add_kv_envelope_tracker_nodes( + lattice=self.lattice, + path_length_min=path_length_min, + path_length_max=path_length_max, + perveance=0.0, # will update based on envelope + eps_x=1.0, # will update based on envelope + eps_y=1.0, # will update based on envelope + ) + return self.nodes + + def toggle_nodes(self, setting: bool) -> None: + for node in self.nodes: + node.active = setting + + def update_nodes(self, envelope: KVEnvelope) -> None: + for node in self.nodes: + node.setPerveance(envelope.perveance) + node.setEmittances(envelope.eps_x, envelope.eps_y) + + def track( + self, + envelope: KVEnvelope, + periods: int = 1, + history: bool = False, + ) -> None | dict[str, np.ndarray]: + self.update_nodes(envelope) + + monitor = KVEnvelopeMonitor() + action_container = AccActionsContainer() + if history: + action_container.addAction(monitor, AccActionsContainer.ENTRANCE) + action_container.addAction(monitor, AccActionsContainer.EXIT) + + bunch = envelope.to_bunch() + for period in range(periods): + self.lattice.trackBunch(bunch, actionContainer=action_container) + + envelope.from_bunch(bunch) + + if history: + return monitor.package() + + def transfer_matrix(self, envelope: KVEnvelope) -> np.ndarray: + bunch = envelope.to_bunch(size=0, env=True) + + if envelope.perveance == 0: + self.toggle_nodes(False) + matrix = get_transfer_matrix(self.lattice, bunch) + self.toggle_nodes(True) + return matrix + + step_arr = np.ones(6) * 1.00e-06 + step_reduce = 20.0 + + bunch.addParticle(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(step_arr[0] / step_reduce, 0.0, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, step_arr[1] / step_reduce, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, step_arr[2] / step_reduce, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, 0.0, step_arr[3] / step_reduce, 0.0, 0.0) + bunch.addParticle(step_arr[0], 0.0, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, step_arr[1], 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, step_arr[2], 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, 0.0, step_arr[3], 0.0, 0.0) + + self.lattice.trackBunch(bunch) + + X = bunch_to_numpy(bunch) + X = X[:, (0, 1, 2, 3)] + X = X[1:, :] # ignore first particle, which tracks envelope parameters + + M = np.zeros((4, 4)) + for i in range(4): + for j in range(4): + x1 = step_arr[i] / step_reduce + x2 = step_arr[i] + y0 = X[0, j] + y1 = X[i + 1, j] + y2 = X[i + 1 + 4, j] + M[j, i] = ((y1 - y0) * x2 * x2 - (y2 - y0) * x1 * x1) / (x1 * x2 * (x2 - x1)) + return M + + def match_zero_sc(self, envelope: KVEnvelope) -> None: + self.toggle_nodes(False) + bunch = envelope.to_bunch(size=0, env=False) + matrix_lattice = TEAPOT_MATRIX_Lattice(self.lattice, bunch) + lattice_params = matrix_lattice.getRingParametersDict() + self.toggle_nodes(True) + + alpha_x = lattice_params["alpha x"] + alpha_y = lattice_params["alpha y"] + beta_x = lattice_params["beta x [m]"] + beta_y = lattice_params["beta y [m]"] + envelope.set_twiss(alpha_x, beta_x, alpha_y, beta_y) + + def match( + self, + envelope: KVEnvelope, + periods: int = 1, + method: str = "least_squares", + **kwargs + ) -> None: + if envelope.perveance == 0.0: + return self.match_zero_sc(envelope) + + def loss_function(params: np.ndarray) -> np.ndarray: + envelope.set_params(params) + + loss = 0.0 + for period in range(periods): + self.track(envelope) + residuals = envelope.params - params + residuals = 1000.0 * residuals + loss += np.mean(np.abs(residuals)) + return loss / float(periods) + + if method == "least_squares": + kwargs.setdefault("xtol", 1.00e-12) + kwargs.setdefault("ftol", 1.00e-12) + kwargs.setdefault("gtol", 1.00e-12) + kwargs.setdefault("verbose", 2) + + result = scipy.optimize.least_squares( + loss_function, envelope.params.copy(), bounds=(self.lb, self.ub), **kwargs + ) + return result + elif method == "minimize": + result = scipy.optimize.minimize( + loss_function, + envelope.params.copy(), + bounds=scipy.optimize.Bounds(self.lb, self.ub), + **kwargs, + ) + else: + raise ValueError \ No newline at end of file diff --git a/py/orbit/envelope/lattice_modifications.py b/py/orbit/envelope/lattice_modifications.py new file mode 100644 index 00000000..b2b59fca --- /dev/null +++ b/py/orbit/envelope/lattice_modifications.py @@ -0,0 +1,129 @@ +import collections + +from ..lattice import AccActionsContainer +from ..lattice import AccLattice +from ..lattice import AccNode +from ..lattice import AccNodeBunchTracker + +from .nodes import EnvelopeTrackerNode +from .nodes import KVEnvelopeTrackerNode +from .nodes import DanilovEnvelopeTrackerNode + + +class Parent: + def __init__(self, node: AccNode, part_index: int, position: float, path_length: float) -> None: + self.node = node + self.name = self.node.getName() + self.part_index = part_index + self.position = position + self.path_length = path_length + + +def set_max_path_length(lattice: AccLattice, length: float) -> AccLattice: + if length: + for node in lattice.getNodes(): + if node.getLength() > length: + node.setnParts(1 + int(node.getLength() / length)) + return lattice + + +def add_envelope_tracker_nodes( + lattice: AccLattice, + path_length_max: float, + path_length_min: float, + constructor: EnvelopeTrackerNode, + constructor_kwargs: dict, +) -> list[EnvelopeTrackerNode]: + + nodes = lattice.getNodes() + if not nodes: + return + + lattice = set_max_path_length(lattice, path_length_max) + + parents = [] + length_total = 0.0 + length_total = running_path = rest_length = 0.0 + for node in nodes: + for part_index in range(node.getnParts()): + part_length = node.getLength(part_index) + parent = Parent(node, part_index, position=length_total, path_length=running_path) + if running_path > path_length_min: + parents.append(parent) + running_path = 0.0 + running_path += part_length + length_total += part_length + + if len(parents) > 0: + rest_length = length_total - parents[-1].position + else: + rest_length = length_total + + parents.insert(0, Parent(node=nodes[0], part_index=0, position=0.0, path_length=rest_length)) + + tracker_nodes = [] + for i in range(len(parents) - 1): + parent = parents[i] + parent_new = parents[i + 1] + + tracker_node_name = "{}:{}:".format(parent.name, parent.part_index) + tracker_node = constructor( + name=tracker_node_name, + kick_length=parent_new.path_length, + **constructor_kwargs, + ) + parent.node.addChildNode( + tracker_node, parent.node.BODY, parent.part_index, parent.node.BEFORE + ) + tracker_nodes.append(tracker_node) + + parent = parents[-1] + tracker_node = constructor( + name="{}:{}:".format(parent.node.getName(), parent.part_index), + kick_length=rest_length, + **constructor_kwargs, + ) + tracker_nodes.append(tracker_node) + parent.node.addChildNode(tracker_node, parent.node.BODY, parent.part_index, parent.node.BEFORE) + + return tracker_nodes + + +def add_kv_envelope_tracker_nodes( + lattice: AccLattice, + path_length_max: float = None, + path_length_min: float = 1.00e-06, + **kwargs +) -> None: + tracker_nodes = add_envelope_tracker_nodes( + lattice=lattice, + path_length_max=path_length_max, + path_length_min=path_length_min, + constructor=KVEnvelopeTrackerNode, + constructor_kwargs=kwargs, + ) + for tracker_node in tracker_nodes: + name = "".join([tracker_node.getName(), ":", "kv_envelope_tracker"]) + tracker_node.setName(name) + lattice.initialize() + return tracker_nodes + + +def add_danilov_envelope_tracker_nodes( + lattice: AccLattice, + path_length_max: float = None, + path_length_min: float = 1.00e-06, + **kwargs +) -> None: + tracker_nodes = add_envelope_tracker_nodes( + lattice=lattice, + path_length_max=path_length_max, + path_length_min=path_length_min, + constructor=DanilovEnvelopeTrackerNode, + constructor_kwargs=kwargs, + ) + for tracker_node in tracker_nodes: + name = "".join([tracker_node.getName(), ":", "danilov_envelope_tracker"]) + tracker_node.setName(name) + lattice.initialize() + return tracker_nodes \ No newline at end of file diff --git a/py/orbit/envelope/meson.build b/py/orbit/envelope/meson.build new file mode 100644 index 00000000..99dddeed --- /dev/null +++ b/py/orbit/envelope/meson.build @@ -0,0 +1,14 @@ +py_sources = files([ + '__init__.py', + 'nodes.py', + 'lattice_modifications.py', + 'kv.py', + 'danilov.py', + 'utils.py', +]) + +python.install_sources( + py_sources, + subdir: 'orbit/envelope', + # pure: true, +) diff --git a/py/orbit/envelope/nodes.py b/py/orbit/envelope/nodes.py new file mode 100644 index 00000000..ecd4c919 --- /dev/null +++ b/py/orbit/envelope/nodes.py @@ -0,0 +1,65 @@ +from typing import Any + +from ..lattice import AccActionsContainer +from ..lattice import AccLattice +from ..lattice import AccNode +from ..lattice import AccNodeBunchTracker +from ..utils import orbitFinalize + +from orbit.core.envelope import KVEnvelopeTracker +from orbit.core.envelope import DanilovEnvelopeTracker + + +class EnvelopeTrackerNode(AccNodeBunchTracker): + def __init__(self, name: str = None, kick_length: float = 0.0) -> None: + super().__init__(name=name) + self.setType("EnvelopeTracker") + self.setLength(0.0) + + self.kick_length = kick_length + self.active = True + self.tracker = None + + def setActive(self, setting: bool) -> None: + self.active = setting + + def setKickLength(self, kick_length: float) -> None: + self.kick_length = kick_length + + def isRFGap(self) -> bool: + # In case this node is used in linac tracking + return False + + def trackDesign(self, params_dict): + # In case this node is used in linac tracking + pass + + def track(self, params_dict: dict) -> None: + if not self.active: + return + bunch = params_dict["bunch"] + self.tracker.trackBunch(bunch, self.kick_length) + + +class KVEnvelopeTrackerNode(EnvelopeTrackerNode): + def __init__(self, eps_x: float, eps_y: float, perveance: float, **kwargs) -> None: + super().__init__(**kwargs) + self.tracker = KVEnvelopeTracker(perveance, 4.0 * eps_x, 4.0 * eps_y) + + def setPerveance(self, perveance: float) -> None: + self.tracker.setPerveance(perveance) + + def setEmittances(self, eps_x: float, eps_y: float) -> None: + self.tracker.setEmittanceX(4.0 * eps_x) + self.tracker.setEmittanceY(4.0 * eps_y) + + +class DanilovEnvelopeTrackerNode(EnvelopeTrackerNode): + def __init__(self, perveance: float, **kwargs) -> None: + super().__init__(**kwargs) + self.tracker = DanilovEnvelopeTracker(perveance) + + def setPerveance(self, perveance: float) -> None: + self.tracker.setPerveance(perveance) + + \ No newline at end of file diff --git a/py/orbit/envelope/utils.py b/py/orbit/envelope/utils.py index d9638d81..bf0ae627 100644 --- a/py/orbit/envelope/utils.py +++ b/py/orbit/envelope/utils.py @@ -26,6 +26,12 @@ def build_phase_advance_matrix(*phase_advances: list[float]) -> np.ndarray: return M +def build_norm_matrix_from_twiss_2d(alpha: float, beta: float) -> np.ndarray: + norm_matrix_inv = np.array([[beta, 0.0], [-alpha, 1.0]]) * np.sqrt(1.0 / beta) + norm_matrix = np.linalg.inv(norm_matrix_inv) + return norm_matrix + + def get_transfer_matrix(lattice: AccLattice, bunch: Bunch) -> np.ndarray: matrix_lattice = TEAPOT_MATRIX_Lattice(lattice, bunch) M = np.zeros((4, 4)) @@ -77,7 +83,7 @@ def get_perveance(mass: float, kin_energy: float, line_density: float) -> float: return (2.0 * classical_proton_radius * line_density) / (beta**2 * gamma**3) -def calc_cov_twiss_2d(cov_matrix: np.ndarray) -> tuple[float, float, float]: +def calc_cov_twiss(cov_matrix: np.ndarray) -> tuple[float, float, float]: emittance = np.sqrt(np.linalg.det(cov_matrix)) alpha = -cov_matrix[0, 1] / emittance beta = cov_matrix[0, 0] / emittance From 386ce53d303e3a1a13a60dd6087df77dada0f5fc Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 19:59:43 -0400 Subject: [PATCH 19/34] Fix sample method in KVEnvelope --- py/orbit/envelope/kv.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index 1552f5d9..e4f26bf3 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -180,6 +180,8 @@ def sample(self, size: int) -> np.ndarray: A = np.sqrt(np.diag([eps_x, eps_x, eps_y, eps_y])) particles = np.random.normal(size=(size, 4)) + particles /= np.linalg.norm(particles, axis=1)[:, None] + particles /= np.std(particles, axis=0) particles = np.matmul(particles, A.T) particles = np.matmul(particles, V.T) From 0a18c044df2a27050edea6394945e0c1746b472e Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 20:00:10 -0400 Subject: [PATCH 20/34] Add KV envelope examples --- examples/Envelope/bench_kv.py | 160 +++++++++++ examples/Envelope/match_kv.py | 103 +++++++ .../outputs/bench_kv/fig_benchmark_rms.png | Bin 0 -> 134104 bytes .../outputs/match_kv/fig_match_rms.png | Bin 0 -> 151704 bytes examples/Envelope/plot_kv.py | 30 ++ examples/Envelope/style.mplstyle | 4 + examples/Envelope/utils.py | 270 ++++++++++++++++++ 7 files changed, 567 insertions(+) create mode 100644 examples/Envelope/bench_kv.py create mode 100644 examples/Envelope/match_kv.py create mode 100644 examples/Envelope/outputs/bench_kv/fig_benchmark_rms.png create mode 100644 examples/Envelope/outputs/match_kv/fig_match_rms.png create mode 100644 examples/Envelope/plot_kv.py create mode 100644 examples/Envelope/style.mplstyle create mode 100644 examples/Envelope/utils.py diff --git a/examples/Envelope/bench_kv.py b/examples/Envelope/bench_kv.py new file mode 100644 index 00000000..bf162bd2 --- /dev/null +++ b/examples/Envelope/bench_kv.py @@ -0,0 +1,160 @@ +"""Benchmark KV envelope tracker vs. PIC.""" + +import argparse +import copy +import os +import pathlib +from pprint import pprint + +import numpy as np +import matplotlib.pyplot as plt + +from orbit.core import orbit_mpi +from orbit.core.bunch import Bunch +from orbit.core.bunch import BunchTwissAnalysis +from orbit.core.spacecharge import SpaceChargeCalc2p5D +from orbit.envelope import KVEnvelope +from orbit.envelope import KVEnvelopeTracker +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.lattice import AccActionsContainer +from orbit.space_charge.sc2p5d import SC2p5D_AccNode +from orbit.space_charge.sc2p5d import setSC2p5DAccNodes +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.utils.consts import mass_proton + +from utils import make_fodo_lattice +from utils import BunchMonitor + +plt.style.use("style.mplstyle") + + +# Parse arguments +# -------------------------------------------------------------------------------------- + +parser = argparse.ArgumentParser() +parser.add_argument("--phase-adv-x", type=float, default=85.0) +parser.add_argument("--phase-adv-y", type=float, default=85.0) +parser.add_argument("--intensity", type=float, default=50.0e+14) +parser.add_argument("--eps_x", type=float, default=10.00e-06) +parser.add_argument("--eps_y", type=float, default=10.00e-06) +parser.add_argument("--max-part-length", type=float, default=0.1) +parser.add_argument("--mismatch", type=float, default=0.0) +parser.add_argument("--periods", type=int, default=5) +args = parser.parse_args() + + +# Setup +# -------------------------------------------------------------------------------------- + +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + +# Set up simulation +# -------------------------------------------------------------------------------------- + +envelope = KVEnvelope( + eps_x=args.eps_x, + eps_y=args.eps_y, + mass=mass_proton, + kin_energy=1.000, + length=100.0, + intensity=args.intensity, + params=None, +) + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv_x), + phase_adv_y=np.radians(args.phase_adv_y), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +tracker = KVEnvelopeTracker(lattice, path_length_max=args.max_part_length) +tracker.match_zero_sc(envelope) +envelope_init = envelope.copy() + + +# Track envelope +# -------------------------------------------------------------------------------------- + +histories = {} + +envelope = envelope_init.copy() +history = tracker.track(envelope, history=True, periods=args.periods) +histories["envelope"] = copy.deepcopy(history) + + +# Track bunch +# -------------------------------------------------------------------------------------- + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv_x), + phase_adv_y=np.radians(args.phase_adv_y), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +monitor = BunchMonitor() +action_container = AccActionsContainer() +action_container.addAction(monitor, AccActionsContainer.ENTRANCE) +action_container.addAction(monitor, AccActionsContainer.EXIT) + +sc_calc = SpaceChargeCalc2p5D(128, 128, 1) +sc_path_length_min = 1.00e-06 +sc_nodes = setSC2p5DAccNodes(lattice, sc_path_length_min, sc_calc) + +bunch = envelope_init.to_bunch(env=False, size=128_000) +for periods in range(args.periods): + lattice.trackBunch(bunch, actionContainer=action_container) + +history = monitor.package_history() +histories["bunch"] = copy.deepcopy(history) + + +# Plot comparison +# -------------------------------------------------------------------------------------- + +figwidth = 3.0 * args.periods +figwidth = min(figwidth, 7.0) + +fig, axs = plt.subplots(nrows=2, figsize=(figwidth, 4.0), sharex=True, sharey=True) +for i, ax in enumerate(axs): + param = ["xrms", "yrms"][i] + for j, key in enumerate(histories): + history = histories[key] + if key == "envelope": + ax.plot( + history["s"], + np.multiply(history[param], 1000.0), + color="black", + lw=1.5, + ) + else: + stride = 10 + ax.plot( + history["s"][::stride], + np.multiply(history[param][::stride], 1000.0), + marker=".", + lw=0, + color="red", + ) + +for ax in axs: + ax.set_ylim(0.0, ax.get_ylim()[1]) +axs[1].set_xlabel("Distance [m]") +axs[0].set_ylabel("RMS x [mm]") +axs[1].set_ylabel("RMS y [mm]") + +filename = "fig_benchmark_rms.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) +plt.show() \ No newline at end of file diff --git a/examples/Envelope/match_kv.py b/examples/Envelope/match_kv.py new file mode 100644 index 00000000..fdef5052 --- /dev/null +++ b/examples/Envelope/match_kv.py @@ -0,0 +1,103 @@ +import argparse +import copy +import os +import pathlib + +import numpy as np +import matplotlib.pyplot as plt + +from orbit.envelope import KVEnvelope +from orbit.envelope import KVEnvelopeMonitor +from orbit.envelope import KVEnvelopeTracker +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.lattice import AccActionsContainer +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.utils.consts import mass_proton + +from utils import make_fodo_lattice + +plt.style.use("style.mplstyle") + + +# Parse arguments +# -------------------------------------------------------------------------------------- + +parser = argparse.ArgumentParser() +parser.add_argument("--intensity", type=float, default=100.0) +parser.add_argument("--eps_x", type=float, default=10.00e-06) +parser.add_argument("--eps_y", type=float, default=10.00e-06) +parser.add_argument("--max-part-length", type=float, default=0.1) +parser.add_argument("--periods", type=int, default=5) +args = parser.parse_args() + + +# Setup +# -------------------------------------------------------------------------------------- + +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + +# Set up simulation +# -------------------------------------------------------------------------------------- + +envelope = KVEnvelope( + eps_x=args.eps_x, + eps_y=args.eps_y, + mass=mass_proton, + kin_energy=1.000, + length=100.0, + intensity=(args.intensity * 1.00e14), + params=None, +) + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(85.0), + phase_adv_y=np.radians(85.0), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +matrix_lattice = TEAPOT_MATRIX_Lattice(lattice, envelope.to_bunch()) +lattice_params = matrix_lattice.getRingParametersDict() + +tracker = KVEnvelopeTracker(lattice, path_length_max=args.max_part_length) + + +# Find periodic envelope +# -------------------------------------------------------------------------------------- + +tracker.match_zero_sc(envelope) + +envelope_unmatched = envelope.copy() + +tracker.match(envelope, periods=args.periods, verbose=2) + + +# Plot results bunch +# -------------------------------------------------------------------------------------- + +history_unmatched = tracker.track(envelope_unmatched, periods=args.periods, history=True) +history = tracker.track(envelope, periods=args.periods, history=True) + +figwidth = 4.0 * args.periods +figwidth = min(figwidth, 10.0) + +fig, ax = plt.subplots(figsize=(figwidth, 2.5), constrained_layout=True) +ax.plot(history["s"], history["xrms"] * 1000.0, color="blue", alpha=1.0) +ax.plot(history["s"], history["yrms"] * 1000.0, color="red", alpha=1.0) +ax.plot(history_unmatched["s"], history_unmatched["xrms"] * 1000.0, color="blue", alpha=0.2) +ax.plot(history_unmatched["s"], history_unmatched["yrms"] * 1000.0, color="red", alpha=0.2) +ax.set_ylim(0.0, ax.get_ylim()[1]) +ax.set_xlabel("Distance [m]") +ax.set_ylabel("Size [mm]") + +filename = "fig_match_rms.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) +plt.show() \ No newline at end of file diff --git a/examples/Envelope/outputs/bench_kv/fig_benchmark_rms.png b/examples/Envelope/outputs/bench_kv/fig_benchmark_rms.png new file mode 100644 index 0000000000000000000000000000000000000000..65ea7ac3070f9feea510dd60c0c8d22695eedd33 GIT binary patch literal 134104 zcmcHh2{e{(8$Ar)%_SO@qG&Kys7%RNl2FFTEQ-uz%1o0=g`{Mr%yVUyp(IHtW0?yn zb21d+-RDie_58o@UEf;YTJL+W^{nStaoyK-oyU0```CLQ=Pe}#89Ew98VZF%Cwt7W=+FQJN(~adua`ORcmAWO9r+^lv4)wHWt?Q7N&+f9F1)4Os%c> zcn<965!|=K#NOV_E^P!JGzP|HZD$*?UAWaORDz62S%oO=O3vLOG8YTu?9Hs|z3Pi|~ zEqqF(EI&V!j*gCYjwpY)@!#L#|NsAe3}3&3B~ea^>Zu`LesXJPCmg@a$R3Y%`}fJM z{P;wMe0}dBtKp(i@($xiCnf|%^`0E3Ye-V7>_#~K_fb4Ye&%V<(*OR3LK!*4|Gz&% z@spBT^8esJiw~_KS3AFPK%u{0N#%8fPIx2X4opY<}l?M;^LQQz;MT_K{* z&lvelqWaT|^=?Eu9o0)rTvl*G&Zj=!&wTN}D~n#iir_b*epkMKU+*U|o3K{muads! zOjeps-Y!|1hxF>7ZXZ7`ci@1EO~!M>|9)-d{0#-aetpdS@6U3rjI)=&c6Hg+7aVq) z85Xfu`rtYHMB6H_?B(8nt1F6U;LNjFDV4*l4s;H_8SbW-FI6YLL zS-0g5zuk!YJC;LH##JGv?*h5{8j^!vy!fR2Z}0f5W@J<{`T6swR*qG8!8zRd+Kmhh z@$r!!TFT1G&Jq2?ovsgp@NOQ9yH9;@u`X^XXYowY$}$snQo|3Ej~7Q&^rGvVw`@sh zOx3<1@-QSMsVY>cfNMR4Vv}QC^yhfE$fd?SyWUX;kASPgmwtwH%>C~2Gi%L#`t5!2 zlM9jVjW759Tf5dO!z``Tp*5Gk?mlopdC{Up!oD1=tRtDM6iS(fi%Y)un(axZb#Xne zr`qxzvQp$WEt{KljqbRV9n(bXD=|Ir++}WNQZ3K6=cqo@{M}JHx5x~$Jg?Y~KW+=~ z_m2{^Z0=4De%aJ?rbhJF9go>R7Y08+mw7o{Jp93xH^a{DM{TTGZOkq54>!`*E?mTh zg^>~esbnJYcjRh_fO*`hP{AITb~>Tfs2_FldvUMwK|Bq`v*WzZ&d#zgU#i^ReBEWZ zN>8sjL|zR4x>j_=>mjecUPAwWPdXo2^zR-^-yZuQwf4u@kGi~wrnpl~WpCajS$7mA zsl>`vZ#1q7`1_Y;;+uy@(o>7zq1-NC9mUGGZ$H@8h{ezS?Uh(oAii*mC4(j=_)p2p zsd|N4x&@98kWpQI%M3q`d?_8TQ}UTv zKj6{Tda(D5I+kM-BV&?n&pY99vAVjttczX8w;#4YA>+sVpt!i$tT83=TUF@Z{rf*8 z4)-J=%9kx&+I=Vj>w#Fx+eu<2yTfx%ce2&aFW~*nKT}+uN%bUWnw&LoRcV zyuIBH*?;#h`a3E=GghbAoMCX4M<@5}q>i<U0dT2dg~##wi&|3+mqvM z(4#G;FBfwOs^>c?@6p#YYdqQ4tVXjYyI`NNu%`R;L_=$y9UdxCg>7c4KOL__^UJe; zJ9+f3_i_f;p}gL)KfRF*W|nxp{GPLJZ8oKJ%k-vklZgnf!xz6EE2{RK{nIO8-7Xrh zc!QIZgd}H?FSA(E$cRl@d3lRiJnlAx-!wq(!5$;M40DZC_3^=$Gs7=_`L@|5si!85 z_ctXUxw`z@vV|!0+VJ+{boqo3lQ(ON>doUQYq3+~{r%odRv)ma_MIh*EL*Zq1qTOf z_F~V=;dSL;j|WW`eVog19Mlq<{oN%eFJF1s_^Af{wrweg9s0iGIh*qxk`=-aKTy+u z;q(+QI||o&S6P|7ZY~B(GZ8M~skc^aOew93cFBr0_1zWst5zG87(V?znA4%Iq7v|} zCeqrey5c@ZL$;;1<)@4z_^@;Qt4ZAqmx@+LIsf{GUHA~SHU8SQrR0@r<=ZE!r)We! zdbEYaotVqm+iYVjRo{o`tD_<-ckkSJ1fg5g`2NE)Bl*GBJXNGOt!#^6ti%&sf~3pO z5gvahTC4@!e%ti^Ek$bn%Pk?y6|=kI=rXSyfD{1IV7zj5P}COy|v4*iV+qB-iRS|LK# z5xBkZ!Qa-!GjY5{zjx^m3z^k(hKsoh_B%K^<$6s0;2?Rt#W_|!NIg>AJ=5azGmG*L zk7>*8qE7quhnG<({z32GpL7^%)hzxydb`bTsCdqUTO*_7N!&4KS6B0okEN$3i{~sS z!*X*EWm$LV{rK^No&8__=??03>l=thQc6=xR_Eg9=kGAzwQJW{_kBfUk%=Gik>B#H zhT99ZGEI~l&Gq&5xpi`tJUl!cn?$kbeOTqj{`&gUcenDfcW5GzZTW0EOLUm{q>diV zG%TY5{0Vuq#}jcFi`(xjnjU)YTJ1SEtv@^TZy}j|yuC%2E?>UcOgCMx@LA#Pc$5Aw zo#*E(HW-~hf4z&B6B!vnii(QEmxgrG z%<=Qd7U}vfKVsbq&y;%8IrN5KGA=B#{}F)5xL+KF1zoNXDV}Q8mj5~ROsbX|sQ^~F zUzX$h6i{d~%^LPxzjkd)W2$;G;y-J&KEY<1@8g>lHlTN~d!*h@|BN!mGS6^S(IhGjle2uz2W z@g}CmwJhQ(5n`_I%(6nl{)OAwwRChm&#?I|(%s$MP9t>|^v?Y(XZfrrWZ8VW=iP(K z$?5AiZd`CJwCk;QOGoJBHa;_|%(VZZQW}C1G1^m!>}_Vdr@SFSS!(s>eHq$wUvKk{ zAq+wutz38>e$kYDLn6}uZ|^vMc(m*L$0si1 z4QB=$JDj@c#8BSY*=^IX{2eYm56%oUx{mk7&P-2+E?n9v?9mpkT}Nrw289S_%`mPv z5LrXnzX?y|9~cHISj-&26ObmQptc!>av`|l0 z!he{@SXIClz|!>f#lfxN}+!HRR>wRN@uF10y1=Z1+$fsB_PmG@Xi$ znki*v6^%#q8+HLqN*|XKas1>F&R6azD%$GEOevuUKvmjCxAh=vOGMp+J!&dBR&BPr zc0;Xs7U{{@I8l>hlaoP+I~5g`XTBu0A=&YKa6lnm^$*kb4SXqO4DgS-!CDoRIUZ8? zqOfqhf+I5FWbi>Nnm$o1Ph9|;eEnnT)un6s1g+ases-0czkhVV>ck4_oo+M8(sCH- zJVJ6|e^YuBQgqgZ8fMvSS6%`0#?z@FHw%sw0E+;}vQJCN*jCB&k}ml|k}@ z&A}szODSwjbaV<64QKR!6i&8RI$FHCwkm%pzu#6j2=92%!N6*BAeSn;wp3}^ZHCou zcRf*Vt|>%_1`q%8W04pdaYcY`JSHt$=qev7bYXkGg39j>{q+HYvVFU`v}!X9O6eIH z`+Q?~)}son+Q@FwS#sHX9FNhDonNPWsm;jtAoWp{lmIoSzT9AW7P4gxi@1eT`>l-} z_FrGG0_ZUoVcumbb)$w! z3kk-%iytnY(?iCT_ti2sj>DdfK^{+V`!o9QeUB2DczMYRQrn+trCu+p-Y2`v<2^s_ zt4^jlGx5XlYRcQtpn@gz3^&$nuifn@8jyM`%5kuHYT$Xz`KKB*Zeq_Hk)}4V@7beY zMSJGKJ^tMXlw-3k?JRkOMn*?#0r>{3K9VIp6~bT9eVY1ecJOj>afR$RxMG#pv)LVW zevJU%QhA!a17F{sXmO07P=cbPU#?OJI~0vlrFiSsEzR(v)rDhl12HY#^2OYEW&Eil*j(zOzq+9)UaU%!4md2&7(4?NXM zMH);8`q@p#BCZp}tMB+bM0a~($(3bmE>I|+(4?+8Z1?R>bGBu&nCry(?a3;!KBPi5 zr0Yv`H2tji_P%*@rNj3RJ3D$=Bs_E`+g;O3@s=n$I}U3#zsR#OPZz(qZrecXN#;&O z{^_PP-K>(%B{xw)=otA=R6gXklbR0@n}#&qf-%(dezYLAeGZ|*E|))PluJ=41Bin~ zy)}_dSmbo97;Zu*@0rKnpE7MO{i)0H)sdN=7m7QNp1<74!N%5OVv=w=QRQ-)K@1Qk zz>ii@&80Uaju|eF-MYMNwU3e1)$^gRN2-K6w#;s~_%qt0RqRnXR5WcR#7ZraQRn3q z6`K&-W5~UGckg~8Y0e~Ml~OQVq)mWOTEWoa?ZURluo9m=QnzekGcw*R-dT40x;~;~ zBOTp!`=4K>#eR2Q_3`zsKCB*nbeTJP6N3CMr%%?Hu352`dEbXA&j?RctIus~f#m{~ ze8mqa-HAMupz-uE`^iU9%wjHEs40}N1?}za>>Tqqw)Ez$d*5nu+$a14S^rGSSA}r> z`P18A@bws=|6%>0yg%PU$G<=E>l-Q!*~b)z?r{fYGIACn!cBMaUByg~`+zUA$G zG#7P_+2gl?Ws&ju=fLUMt|Dz0%eP<8H%2XdUf7;vt$(?Z<&e#emVR&xoAw|halQ!% z*ru)jKJt*$pPnEA*9i+0HEtQp{>D_Gg?oA)e~kXU!ACwm0WOn*?YsC6su+EH|4~V{ zoK?D4bhkWmo`B-&2w+(1WN$q5|#f?RhttEg8ZH7ee0rDc{oKfXN zQs*}@GwXft7qn_U)Y1=J){naNN3Zx|*BhO5+}I9J&+(nln_1jYa;>C;l=NA-71DIYop>;WQE30f<{wB97fw)MK_^~nj z8)=Iu8Ghd0i%-bPemv(V7MEq-WW4>?uU~aS9d2DC5$^=d>XlH(pX=%8*|KTZ9n(vz zVwDBD^_Ox+2{_RGed7|g&RbW3?qw83e;)Jgs$#n<>Y;OiQ7|w>@WHFn*qbX`PMn<2 zjr&oFZmdy}lPgl--EEo|<8SWU=04em_-PCiwnJ5a@an>#iI(h6zLu}+WlnBwZ!K>EtE?U8G99WGRG_Ve^`ngt~2HE$bgD;S>^ z=<+8p16Sza3MRMuwR7W&zUBsDVbRw5MAe@D{=F3wM=IE54+QLDZBRHF=s4iNYj>=$ zU5x)aZ9A#cflM2z!Kn0lY$$x#*gN^%i4d-qi4CL=Zq71qc(1uu|9uGCpFf*SWS_-| zd(L?bHfNau)YaD3hTUI5@xPAFEZ4TjC&FXO6i<0cvz(yCO?%b9UtYm%(>yIY_xBg5 zs%n>+o*;cQKvCzkP*G>w>?TEtnasa5zwa_&$539r^eOn_{VJ7i^>eYON{j1Lwa-|; z`034j&oahHLvQu2-Ilu#o=LTJKSX`SKKb9ji{=DpaOl)NbpAE=p0DPu;nPFBswN4U zZq7xai~(#8{`BruPxU?iNb?qs1svq#3lCaNk(83sJ9zNm*xz3@{a}Bp4}a_GdIHRT z6pv)r=ZYk#A1-pK+9mwq!#Ez@d``9?p0f1fS*_I!Jnvlw`}>oXpBxt!!2NPE&rbF8 zI*2;RRV>r}-pf%H_QU4{v-xYOwWfI%ik{u_az2))+3ypofkJuPhV09oKJCYy8y=@C zVp_VqMQVHAC)UIVF%8SJ*yJCYjC8(C14dwb2+qkVKS3U){6|2s@x%2UizI*KR3pH{9;6P$fQq5-n{xSOyb)?ZbF)?wf^Xl6Abp2wB z{%O=mEFl9Yx#O+N*D|Mc@Exo_@@}rmMM9!wBTaO48eOl!-y5`CzaIzEqc1nDWA9yo z%nI5o_vT%P;i=YZ-pw9qez%?q=)Ha;$G|JsQ;94kt6R`F8qDY8IidMu%(PVgWcXn< zP&|Eg@qPx|DN6e{CpVZmTw1C4?fpGz5D>}DnWp!9oq_fmmaG-^w@hcdUG~`De_cbO zstkhu%*m5?2tu(01|7@<@nF%S{)qd3Sfd2we5(_vaIB`tW%;O@&-HG+%^p7QWOe)1 zD~tPEUYY53H!5l>8zD12>1LQmCNi7_e0$8feY(6!qlCj~}C5J2*2^x>mSI)^Xqy zp@$sI`LJU~PNJO_jyo(ZZ^p%?Q5%tM89QRrvSRU-tEoYq#@(he0B^;m+!z%tmz(fq;YtVEsgtLzD$}dU0eI+ZgxDApjDu8 z4bSI|%SD~X*r;zqTKBo}knS*RPKQSUIz_9=BXua*Gt(V&jn&~Irxcb`%2sPD&@VDI zHEqtl_+$;UXaX9TM4dd_B(>y+=yB7cqIO&=uk|2{@q zEbl(eoVMjo5fzD)oGW{MV&~55`ojj=Vjg23W%`=4lG~>43biM^eS2c)9)bHt?g}E}i;PdSm?cMn#jZH+T1_B?VUephSH?SGfuo{>sjN+~=mh zfT+$+-r|(I0mkxX9#vc@!-NP9UF>p5M&`^=D_5#kPax;~w{ghI%DQ~L#X%1xp!*8X z#IO6t)%Mc+Zrt5+;AmUHr5x>!XGXW%UHZ8buWaO%{ll52#pUlIz zC)&aS9^1&S4=`l445Z(cs2Z8rb&fZcLo6ft}_m&YlDCm}VTFVy2k`Z?vyO}qNO zpoPD!>E@B8;^N|jd;vGPrqt#5ac@1RFU#0C7@P!`Q36e<;sL#bvU2t<3K!R(!-aQZ zn5HL;u1H!LS3MJ(`EnEBc7lcaErB-JMz#JsrEItPJ*-!$H8(JL=Qgg!C8}dq`+CCs z*fsj?+~97X-rqV)B1|jKHkM$p(kaw40sHSt_f;23el!M@RljsY^5?xrj}pARytb8Z z+_2$vvO2dA>tagO(v_<#?G9dTa|j)ETl2UZl$Oiii!GZsT;H^QXH~>t<_YSJ&(QAF5iML3^am=yD-zQKX>rJdP=U}lSw~!o%J+q zrLV59&a(OP%Ay=3eA`A8<$yhh^KGhVYvwW*rT3eLN>dLiHT%1 zC_i)Xu0y_yD3TS~XD@g4o0`~!-)3kFr#=QH=kxOmesBC(taFOazFgeq*kZ}fey|2; zARe^IkGJ=B3!B|o%hHI77SR>0Op#RJ=a2fZc*&B6e20GOBV^@eDBfC3@w#GXznHRd zscrA@@TaNKp78tB`19KJ#w;u8LQRAthlm7t+rCdvpHw8iw*#L2@x)KO_Uc-36AgVJ z!r7T&&;DB+5&MO=Qs}w$hSqpJPR8?S6*yXErz5IzMK)6?Z1O4r=lX+p_!k&gwH7dw zC-B;3MmQ|+LUiUxW{r2Y@|{#TU$lbRNiw}?DyeO1Z~BYJP~0AYNAO{$67)U?*;nSO z=UDls4ihLteGi;RNz>#pGxa%DF;wsrR4={*_ohklA#7YqxTv!Vs0057GXddE6#DJ+ z5o>gEolR=z*+l8vN4c}SuYYc&KC;rQG4QDus>2SXWLdRo5r|N6t2G|cI0fFUyT`~) zeh9DAcuIiMeT67TUXSmrTAU_i{;<3EOcYy1z+-*4j{@_XYUHeWW6H;`Ww+_fi;9W} zAGmMx?TWX=x8{0Pw)uJnz5N?#SkoX@7_J*80s4+*?nibi2B8g7rnE*>6pG9 zj*ZIwH9p=z?P$dgc>Hz3>#Rjb+xcfc&3rYUn=M$#OwUhkTS@0&kYvcof4VtS*2nkZ zu3a%BHi@zu!>wC2p0h0@C2=Z*Z6o_h8%1^M1Dym)5ro!KWi^9v@=s4szjaHr#xkcZ z4x65-k&w#}I768b02Cr2=Zh@$@%z717s|A4ZJ!~w9l$kQ2U6t{%~@t(kX=E`&v!@- zol6#o!cr|j3M_<`?Jnw<>+EAc9wMRdbN7J&m#pXOa&wR)A-tyj5(vjm38ium2TW=7$FT-?W6)n$xFunx>apYIPVmwITY+15#=g!(NVU_bS`@m9E zl->66r{8V*B*wp35wu%AyJEyZ(F^7{^tg@^GH>6$RhpZfIi;|a5^;AGoy{KdOx!}IUY6^du(zrIK_G0JO8<)okdfPaCL&?VUA!)!L6) z%*1&Ay?GIe&Kx8iwky9d)E;~kHg9?`Y`k1{&+Z>{FJ6qDJ{u)}Zj&@P<~)Ve?_ho* zm>L@HqKxRw@5m#-O+?!;NJU#unBj_BAJTM11T35DGqS-N4|WuHAh5~jkn(W*A1mYB zBzxnyed)zRk0qsBpn#=jWb7|(25`wjI=sJek=KRCP;@9!E2qANT4$O!@su{-<}ETg z^lEilPft%Qnn%V)TXRV&3M=W7mI3v}U}bqehJIsLt7w@Qo(g)XWsbPv>y^5>HZNZv zqjUz(N4=qK%PS}vga%{hc%?@0qE*o!KP4ru~m}pD`o;nPCI$*bC z{%#UtSj!vrUwjYSR;Gl`rXk0=V_Uh1oR8e82D7~fEjLJ#Uv zKvsoAmVuS~UcH7&@ZK{qf%Mv{71iP3YO_5fBi+8fc}+RHklOuQY~ZUQ6;F>@3`y(yA+z?-c4J z1s<1sMt}Ze?!}X46s3WM>z#}c{cLsj2W>>W>*Nr`TOR{U=-Y=qXJ1sz+eA2HsP%-} ztES4Ny>Ol6(cmjpD|8VSp`kc|Kvgn9!+07X=$X6Nc)jY7?=p(yQ+gJbbo6>#8m$Tj z1*udz$5B1fxfi)lGZGXYKiT2=FYxIj9KM~5b=fqM9S|A$I`GvC_laOjrdzL0$OUZX zb+lrpjO-va9?k-kuY3#rP$6r_OZ$*%Vi8SycJD6D5Ip~Oo#wvleP3?e9`9?A2jhJ( zrEq4VB_Bjl-evMKD4a3F3K8}9gM;O&hZj?2WG?>t2Ty%&$lfP~TXYNYC6ts%;wuif zoVoqVHw>+zBN)4r5Ek~QK)dl z&<+U+i3Or+hv!2c-6Y@bBE}+(Ix1&mE%&I`rwX;PKHvqz&h9X{XW5E^-Nql);_d_n zsQe!H@KCWWx^RKwm56TS{WancS?f5|DqJ`>JMEnXVY2T!gWi7O^)!7TGS3`4cFkZA zipUfwxs&q&B{>@#A8-Ep=6YdY>jz^YG2M|K0om3;)CMdrIC{UE8wj?fKs#HC*9vNm zD!Ez}A*Rj1tH+-*KHQ-XO-&G&e*(qFF@FEa5Pn%8R(1|*3%SQsEGAoSQuC_B#U!>HIG-DyALW@NdnXBcCs}dO2m{15Li=?)D{Auq{GlK=H^QDHl}n;eYX--1+-Ou zd4{P&$E4eSxPJSp+r>}M#Y*2EZT0wiC5C}b4A`I87UcLTHVpIc`#q8Xpt0xHM$!T{ zq-fT4AG3+uDdqhZ&a@0cgI7zjkrpb1(qn09Spx%=6F2!U_|k9X>S!xycx9$`EoO@> z6WjH_?o(cimJro&vWI&}&rKN~hN%I*#Ea(=-JErQ{`|O1R)kfIBk^%e4J&vq1=3V% zcP;ix)_jg_5!&yF2C%6~#hC$2JLjN?3NXn1~RM9Ok*OjVOdS0x}uL-rS& z<%4cS5j2DZBp|E1tI7+1f4w~gV+Nf$plg$=qL|Tq+)3WbG<#4VeHGTD-o%Okm(xix z!Z+4dO8Bi>Y?Jn@wJbp(bmzRiA0ZDFMlA21gdhNHWyok*_rmgu7*}s&#+iWYjNsCBp z-jZY81m48_-{aIRXfd*iK~rNFm3MT1!|I)Zf=p|UE?>>eEQwru+x)fV7e!thfoc=Z zvZ?3m+5M$ZAqE=X+-2f$^rph_+>`e95o^zU+O(Cc?DZj`wWDP9K>E~WJVf6seS32- z_QZQC!{Ajw|5bKnY|IGju>&Ys=imfr&)B?ud+Kn}boG3sdu=%Pa`9xEO!QcPlOoA2 zDbS^4!PXqWe$8d3hWAj({dNBQfI9!dQyq4}#=?GOPC|i0(4jL&S1<*NlqB*r8A5J& ziHxu=Wraq0(ocLU!N3xn@v#mpWxv z{vCvJ(?sn7wnuZu_fBs2{4hUZxRw(2i5TdzZN41M0+ZT8HbKu28ajG9 zJh|r7p0#pIWxavrD_Az)SEQGMZqD*y!8cXtEw)y?2PfQCJ5j zEh)`jFLYlxDMJ=&1lz(UyEDL8j;6+Py->RRorI519Qq#};LoFeosJPrf%(nI5G=Pi} z!4;6?yr0@{o%jPJL<_C$2MYR=;Aqy{zC1d7S6Sg%IB=l4ikjd!)vZf@f~nOz3(3C^Eb)G!b)uD5mJy_b4`(BhGgI}8 zk?%HacpM+$@{W{95XGmF-wvb@k-fRtvzTmQVd@s%UjaL6oYajqTN_=*zDI+^Mn+*~ zBYBRReah6~81SauYM3K#TFdI}e6cct^A`mD57AO|=3BRJ4LNl2G4*P{htN2jz0&Go zGd4c1Hs6x_-4E>kGIPa0Y{p!^i=m)08ONcS()4^dh%zO8pB#wiAK}%Z?Dvc<4PY{>7%P8vcN4m-F)SYVLb@W#7d- z7+){Rlys0F*--#SRud~GkU~s#bCaHPs47mGaHy*7R@>R&lOP@?WGPr`T{@08BjU2=CDLHp&7!8N5$BV&0dVo3FAD= za;;7?RXyhd;`wbQTulRw*h|KS8|YU>N7s(_1Vri=DJX)Ssr{~&tiwq4zABBKe6;^% z1`>gu=ZpjPP9Bj4QKt8&kPhXr^Jol$G|Gmi?Zerp8qY##T7UMKsv?b2X1NX?B;Ma- zgTd$<%qliE85OsbSToHzEI*xXIlhY_lr<|LQ>&I(z>yk4?ooa6N=sjZh^`J3_Raz% zHHV&v*ZcYJ-@p7eosy-^J(WR3j7LG2{BkI>=QXTOtA@ zNG`MS(DI1BWdJLvhblO!QwrC1aj+lP%8&#L$D>#Ovoa{l5H3gm%yE|ZXOmoHn|CI` z8Kex!JJG-r$$)YHSubp)H88QLD=GPdbG!G1;A*ht{rUZA#Aw2H3yl5hh7UVFGp>RS z#-7;9&gZFa6LnI8*Hja^V1$ap&TeF4O2$TDYJ@vJ6*)eHX=T|_*w6`?gX{Gspg)$I zo*ZsM?lJKo7ITVM`KN5lP{JbST3*5)&Ac?M_kc_F4P8a&8p866+&c%G4WpP#Cfe!1 zL%!`2JY&=mkc?p@t)w0x6_Ztc{UffDuk1utRPYH&{IOrwEvQkVK+6AhfQvx}!rMPX0K9K{RHgs-45r(uAdI+m0=e1M;g0ncP^z98(6&?qkXz01m<88D!se zSBSAu{O^bqtUIq4p83)=8Z$U_&uN%{eiqB@I&c83t15y1?o(q2Qo_aEwd}sVC%LIx z|1uLJaixs+3=R(ZoOC7zg@;Rq)-Mb{Ohd4^PM}t&I@VelVwiy?sEpCkJ@sDub}-=$ zz)AQz10xde0!aa*a2hO(YZQ!gsmAR;@a&o^7L(XnOYt)6?9qCYjWer}GSEWdkUM$u zG@jYFYt^b%R-xYkJ~WB@8z~v%Sl<%BtSA;-8g|r{;`E7xPD}obpA#rvp}23U4aKI2?HzMSr{9EtaNT6_#ct|eb{{} z(*WyjmEZGF8*!+pmSv_^2>Y6M))N`OJ}6HpWt8rDguvkhXNkj)TDH<=w7A{<{b+sID`;l;w?I~KDQCc((U~J;J_1NBG&}n%!8!$og;{98!5P^W z$)IctV}>q-r~N4?K^my`)Z4BuPZ5$kb*ceel>Oh|7r`qZfo*$P(Hk(+->;Cx^L2)e z45n}4Qmu|6cQq6fyCu=bumE?K(=o=tmc%E+jhO><9_Li3P>NoP%xfTLTTpKl4`gk- zi+&UF-UC+B#UD5sc1W2ZibR#zR)1QG?K8{`Bq#G&WoeD0)iHZ{Wtq>NJEsxMQcZUD zVmiG4Hy#TwbKN30&C8cBqqv;+)xzerhr3ZNLFpx3g;D@32ghDc&bKyu#VH1OH z%>x`HFI|o7H+Pu4yt7C*Q0Ov__uvx%tBM-D$^t3GcMj44beGrHcWCW-T5Nam@F-kr zcaA5#2dGKwe7J~G)Xgs!vsPReW4LaMu?6>^WelVcU=ux|*|Y~PpY!g^;5DCWZqke2 zuMZQd!gMbnnls_R=>SC&6(hy@`AX=G-UWUvxx9qV9Oa`CBRLDpXA=v|{K?Wd0ZLCB z_cAX6P4}^|bR8K&N7T9V9EG`*jgAh(E^44}>9=nWZ@7cfO5?z-Xlkrc;F!wn)VWC4 zb7q`4x+B~tG$Co7LjP3YAgOZ4XJOG$g*o%2!nJ@DBICvHe-GXd#$^&5 zS>E}l!fIn=MxXbISDOr8y77o=LS?k14QS3<5riRD8zv(#NFx;#C*aZq-DdGytl0iXEmA+(e^qO}Hw@Os z%A=h**t)z7Uq$d8Sowccetd19!|TtgpAgc5IQyNBKgzOKjOGh?cy&1foo z{?3R|hI-M6#pkGz?)u&P_kj&&51{=3&fc!_93ZAOB!NUEB%&dp@8@r-olu#JSkkqb~pKGkISr=W_~ zPjqx;6)k55bg1SwL66qli}-RPo}KR<^Y-2?<9p)SDMk{Iq`+M$zOIdeuF1fo^8q}^ zI4ssl2uGSVYm8aocbAI-f-M|x)b`FoKi8A*$JS}Ke*Jn9Um*hW{}W$ZA=mI5zu!_C z5)>4~ekuekF#QS$IUk^(S!%R^hEz|}F}2!3`Mn}uh#$>{(M%Br@~Vqow46@U(L`pQ zkEjw7jgzJ~L7(==g<2teM zSzqqQLLfDrIZ62P(pMyYB*d)U! z1VUo)V2T*Lh)JsPz7@B;!eFx&I9oy~U7%#5zHh~K;rctTK}t8c>9crcLRg+mZ6-eB zJJ_$cOevk7VeKDmS}b!CL3_eej@Y_g9Vsz9kb?!^f9B*J`t>`_opM8pMy?3Tg>WbS z5s25=x0z7Erxslf11}$oUX-!1-E~+j{LsZ$^T5UH)h8G{#D8}#DQ$*^6_0L_ygcRm z?5FCB++9nxEG+hcH_E+R$Hd5LiaszPhV+3zWob^gH+(_UN`*woBxG)H6f!=UX9NMK zhE}C^1&do0#$$6u*fD!~=5!$aX7=mXPS|~WyJ2f$sHzG*57$wZJ0N$CvWoqB&qs=J zDqm3oodvrUyyJ4;mLGj;#2*`-XR&r-srcNB6u9o@ z9dL_wQ1)Lg>wCQQ02P>E4iS=P|MMF0I=&jwE}xvAD~TacY_j$Kcs?j#YJ{ol zuIBVYhD*fMns?n6fQ%==l*Cm}S3&Nd^5-X%-bDO`cNT;#f~Kho%qE}bm`yo~mwNhU zjApPf(B zGl%h#WbB1v@=WuEM#v%M!%j+#WAVNi2_N>wnQOu6s&g@n4Jk|UDn^x=nPMJ{2Q{#i`iyACt8 zbF%WR;X(C3hU-|IyYE@3K3Noh@eOXJ^E@JS9ok$nWMv+@>UP;KhG7e3Ln8hXe-d!S zeTM;16ipz1dIS4qjvY%tTlzeDnkw=oO89wcxmc z3Y)T(&p3B}eFJTF%gA-T>2cOtCL4JoiT6h$m#R)U4ch}g<}m|XE((X8tW+tPg6r@M2|ufZu`5L=uSuN8gY~H>e(x-DXGwN?%8w->bwnODFCkkSP4wImCkSNsB3U;xe4&;7~SJP8o;(k z&aD2e(Nm=>Kcm)C)^?AjU6Gjks|rl_u377`L88kP73 z`-i^|0^8h%u{^I`Z#z1kj`vhTA?-X*KxOC4tK)B&th*C1#Ym_)7oeGwHPrOTrk<|1 zOwTYcf2fQhoOwm(5f)0s+se-jckbK?WCi&%?>fF?yqtk>ji-d#0tY`~JhlzB(Q8+l zCLbhmodgtnQq3`yD&xD2^s4v-Dn+`h{|+sem970+24eMu==UWhyM+s*zaY2*SYf9I zeCu!2wsx4%E|CmAX!MNC4>_uCfFmH6_)R;qlA%HK*f_{ty@!U9yu|s^qjdCCNO$|V z*Lvo$MV*&X+mvQQhLSN{B{Dsl(S?fpS?^4uO4%t{w76fdT#en#O_L+I?|nA&$XT>J zO4x~X=AgM%F*`etdZLydcKQI8bvL=iCAh_CxVJTn73JmaCVC7yaYb~nlG*1b#ADDn z=V1V5*RDXfsmz0`^BZdvLxk%#CE{cYY#Z20Xw6TWlEAx0{kyhF}-< zMz%KoMXiI11<`uaRKfiPR@(*kk)^tX~+v?t^M%h|aL>|Wo z?`It{CtUY$!Hwfkh!3+f)8R9lbKjsr6!7@_+oGIcIIOb}8+4SLnptvY4RTZ#v-DLA z9aD_sU|8sCo9GvD{OHv_E-b;T`m{kTfmn2O_KHiRpX>einQF{T{rkclve>3oQ|`qc zGde#vmsO*j#A4JqThbh@WgIH!4{Tt~a-x)b971N9-ML2&V|Q}06?2TYrOld8!}|RA zN$jc6-p14j_7rXz=nce>-S6MOx9KByRXVm~Bhl8}25$o= z3T?Xk*mq^IiBIRuFm4xjGB}{$aXZWp^~Adhu+6n+&mL{d-y>fLChMBZK%_4%bY(~Z zbVTIs>nJW}b{jcDgm*RT zA1b8xbsCA1YQhBkb2LDYx_%=cIMj$uo)=MnYA7uL)Tx$qS{ZX@4*~;YV9zuM{6y<2 z=W9Op{i76igB@q&lMNd;qR9GpIUPNErHzBKh+=d5yGc3w-eWR#AG~()Vjdkc{7pbn zcJ){~5YXanPF;72*$|(yj=W$#wVxo6I_Y8rl57vnv<3jji4pk z#E5F36Y;c_4ujXcQ2V(+z=Jzd$7u>|vHRf<}9G2BSR@Q5_1-~pR#ayc77*k=L*B8*d*@^|8(RS$h5yRd`b)%TYu72 zJ=njN^qnR+Fhv4{{DR3mi#&18|j$@$H+VQCOJMI|9$4I<>lgH%V~MEXNzEy zV@}mAXw1kqC|yoWVo+8)Ka%-_TJPl-@|w4N8S-BK{5;%B@OBU#32R4q867UuH{Sw(OPwyR*vQ{MpZ6Zx_B zrhl~dsU)hX3^vzxzC;)ouyLGyZNfC3OlC4+E+tt(G+0KEA0zdLv!cHwfhdjF-&idT zAwKHu*`rJR*|5YUc+gMU)?+L^6EnoimMvQ#V(2CE+Gy86{DZoYh{icIjE3_OI!SYg zQQpLnn)`6x=DtT6Lj-zr7=)Z2dS-l zo^e!qfftqJIXCOr4}vi!c#-rg5MuVAlABX!U>X3!r=;UdJ@Uy*+x|bnePkW+ScBk* zbQ`@zT6IJUKAav8_h~-<{@tXsdHbc-XpD+BcOR4d0zE;DIQa|)A$U9$DO^OM@gYK? z(!pgb_HrM}wJ}FJeU-LM6tYt+@iLTZfz?8r`R}rN1XW{{pkN$5ZQgki>yk|nFpv8& z!{v#H{q+i(B2_44Yb+S=E##ZpXg7)23U_#g6G@i!33g2+l7VB zACwXt2x#$wOr64MrQA|~nmgz;y9Bw3o=RAabi&ryMAnE;pX7Zpa>ZaU_(H@-tmFcP zCEbByLx#cFFdUlzs@{6Te3%P1bBN>22)IY4)Ex9V_pXT<Oz!1Ns|uRjQjibP;Q!U3#xKbJErR=SM$|P@ zs=am@7p(^n(LdO9A{{XpjN$OyUFl6|2#62{hY>Py&e*0q=alYIZ{^6{gR4In~ zl8E~E^y$;X9)EL*{d{a}Y_V?Xe3ImmTY2H)*jiQ!#h4hF+i_M$X)|o34F#91(WphR z@$sn^UcJIU_+e)@L;`$Pi2WVG087CzEwPHIqF95BIHZrtFb*AtsgX1ZVCrkg=Dsc? z#P0?wy{{!F9jetc-%S&Ph)xV9hHawbIf{K=Qnww$*O0K}6cnnJlc8pk{_3F7sKaUo z&Z5VU13x~CeNk6CTKuM_CYyUTx+r{hRKl=0Rymv zF@-hp((n}l*sA8w$r>f!D7l_=!hk?6sfr=|w~Uw5Gr@k6DRO-$)JHTOK(Ah3U$Jdu z+{~+&f^GG3V!5XftByMpOoeJtWnk4?Ry34#pSd&m(Fe?xohRz**|Sk-E5n{RmeL7v z^6>b2FW+&v`6<`xj~{W+)~|){6#%n_LeZA7nVC5aN2%PsaacL!*zx0gaN0wLBM|wX zg9ig7eo3zC{yx)n<XK<4};4tY|gSJ-Uxay(9==zYWE6All$*ht9|at4BJy~o_lB{CK6@;&+nsCP-_ zZ)4mXuvIv8zrB}Y{Tk)!jJx_+qwUL1CrViuFfbVrl+Bi<11mxvp{Ex^qH?Ba_jXgn*?=eUPdy3r;t8C}X|E3)0zl5B^gHD^N zk!aW`Q!upcZ-VAI*a*X3R1~4p2HWc(ab23|!JX4s!1FHm>{q=rz=~R$jxcVDIfdFA z;d)-XEC7ATj1H|iER%&eMhu3A5;sCzBlBI*xQ!X>1+$)XFkTRuFBqSO%@F+zet((m z#DHd1m~dT&BRIZf$n~gKqB{S_oKe(GjGmF-Ym2WzGe#aQn2E;berp{69cHl*n8`+~ ze$dguavFqxVykGpwGw250y&(CI6F1^v914Z-=4mfUg&?FV&rYGeE|D6hK$JANDhZ6 z9DTPJ-`|Rp(T@3vO*}FnqxVzDU&J|(VCy0!g`*G}FsXswk<;K#I^Z$isS6uJOa^$%uTHDIpXMEQ*Io&9Iz{$iw-jw->xrG zI*$hJNC25+B>OR-K3Y~^ ztDm)|~Jkjr?4cyp?nh1T6#L^?yfAp~No>$7dJ{2*;VXo(U8aQ^3|m*F=A8acm# zZqCEAk~`-+{^;-LSLv8b?dfw`Fw~4waxfS~m~jME5{`*MX%wxi4i{;Nk=l&0&ZU|7a?&zv6bl2lJYlSF}r;Je@3DQFGaL0zZw^j(!y?nP|_!sy_0DWu% z@Un@mv=PAN-jfMz3Db%IHW!GP3oVomFQ5Z)V6;s^T1Q%5x=dCgtc)8B*P~4 z@okM0YsAq6q>G+c(!G+Ma1a6xjg`&*LCdX`85JD8Wi>7BY3$SI?pY=uU$s3&Zm$;^ zesPZYD)1$-c_!zPRB9F|Jku!z~8|T6=t(!p@1jhlo>R_ zY^7im&=(Y@eEVjuh6B!UJ%1bpGv6b7*^%?*NcUwhh+zFdoxxp7FP3-8^~KLOOj*R; z#G~6xBL7PHDU+2nH1DQnK;eYBW6ITQoALWc_xkOZ1HClmXG`N;>@$9d7Wi9fRW$hHweq}M8__qV;7o%L)aJI1gKTup9Xli;>zzT3BjYC7 z;haYZ3f$iUW&mSt3D8)-B>(|vVw=NE&wj{p;89;=YBHpS-UO1h@%I)p=hFelSzfKkhJ%Zg}TtphE;WesBm>9Bg_FYXw^(G zq+IO*+mY8kQh$)E9#vBwk>fTUC0?LTg^@ns-^2dxn45{jX$1)FPvKfCN;JrzU7_ox z(q!w-&}R)~aZgb&TCRUdInIMCFH7#+w_0M9#?&u?MA9)a+k$jO`boVJlV z7J_PNET_RCiz8$jI7q;{lH4EF_%)P7X-|A|wITeWiUB@a7d1 z&bA?Y@A=gHXaLQ^|HapPfOEa~|KlGVD$x`fX;EY(*{L*TmB?Oc$R;FIXi$-ctgI*_ zv&=*xl4NFPMJ1x7QVPZY@pR7jH?He<{k!h_+}F9!DWA{#{Tk2b0(xHPB+pe5w|7Dzo-_(zw5CoT+{kDiZr42*ao7CVq=Qo z80U9-yq~UPI%#p8z)AApUoINc=iDu;ntAutFoRoycb|}uATXn7`uE*CLW_?xjCBx2 z$qWmMULzcs2LHn(oM{~q*>?FovgLx-xETToJhOm{04YR7MD~CMf<_9L1sbl`I@}`f z{sV9PE5xmnf z9qbEIS2%eNpP=@Scd=wCRA|1um|rH+V6BN45+mM4P z2ZzkonUbSV_&=4i-uD#Uj>41o4+;NkQ%3}FoJnMA@}+7H*Xrbbw~0_`IjZf)z62{N z8LeR*Hon4nVpHZ1>|io=Fn(a1p;*lBx(vG^%_XX?p~S}rUrQcUPBigW4argqHyDlF z@yqj4KyXh@QiZizU>upq2gF$aj? zlAA18#T5j?K&jsUP~=$HIB>0hU4SWZD=JQG@LvLXs74^8Gu8+bKmPA+TCn@T0obz% zrCdqyJXZhmROLJfDf8NW7bV~&5qs(Fvr6LKU|IyBsk#Vuhe}liy=buyaxwALI|T;b z{P(Dq3Wg*YPuLdi&y0{8rJF8@07U4*uPJWsH4bk~3rUPJ(9=={F`KUKN2|E-2E{a^Ppr0{_MtwYI?cV4HVA016$vzImRjh&)TZs+@IQYeb zd|=@)I;+6T#jmdqS?5Adsxl8W72;)E4rA5=%ECqbrqb>i5N=o5e-z2`4p6pk)iFFo zVCoBmy3X+oDDZ2NX1WZ!XU_{yZuS*`XHFV^d%waP)5a^gGKoFMFE;0<%*axtL|H|c z#8H{eOsvsL819S- zpXDnA_blME20;F|3)Kd5g>{~LAZ639iA53Z%V2-@FJ6z2)~gAbVciKOKyALqaty`! zwt7Dngo#`E1OV7vsBX8oVKr8ORU+e4JZ$qNL8z+7f*grkwbPakd0oT>>~DXFhMK0Pm01><%)yLB8UsTI=-ehg#D8n9>VbIOO{mwkCF zq;)W(GA=f?ZL7O*fl+gycMd1+<1C3>!(8CyG!_wl>T)w8BI4&i;pj!M!nEoche>Cm z(D{GfIvZk`M3lgip*oui!Ut0*n?FuXj>yA~gW($p<>HL%Was7&*4o$Eeoxqbv+#K& zqmDyS=Ev0J&maDr>y|8YnBE!dvP*3dd|Yn5e?8HjgD0vI_T$B#qq+8?CFi=H{}_c~ zP4B6ty_R%@>ov$TC>KD5C&HM002 zC=k)t&&b{^5vc*iO3S6dri&P?shSF`wQiHl^BIWgisDU}-u$7^HZ%|jMBM)tLAZ#Z zDSk>Ko*8Q$*|UrSt+Q(}@@V&3fgkc85B-slp(7O^adC0!0+=Z$9rMkFFbvhQRA&}O zunuy+SHjtW;af(o)-)E+&CM0a1Bc=h_P{#bHTChX4COul3qS;0D}{_#XSS>J*?S@; zy1p^}_N%Kfse5_1J5GDMkc0M?-R>5F$)@|aCtURJ@BVmLNL({}GwxVZiU$0c9SswX7|xwNTN^D2kd9JbxDCeR47Uk=I{Q6(OIvE0-um&(9C@W` zckYgMS(U{)tJMlS{H^@v>&qYylvM5b?X7ZV`f0MCe!*{Z0$l}cuFndzalo1Xo=mpG z)`g49bu&fsQ4Az46f>~BnegG|vG>XbVo=nE4crY&+;MKMZn!0180|R0KmG@ z-uik1_QMd+`Wui+SEXPXMn8L+ynRwH{hr>xjta-lV227@*x}+%d;QvQm#V55%&D-0 zhtMm|`vAfYWc`MyW{J`r0(x9aw!^rzZvOLCMKexkXc$e!M60rX@~l^aWc%8|Eba$l zrPbA9cGBlJ@v~>j$$)M4ywPjH45c#UAncm5(jO^T<*GF%@X6+`+7cTTqq49KJ*I?N zVezRIDCyAkF;_DsK7QS@WoEyBa`N5#vH92Q zSa&V;;6H!Cl}vE#wsupwF@_#z2<)Mn}*e#@2o2FFK`kuBZo|Q3|hS6u6#Ok8+0p_>iLe-7M#Mv?;^X z3e#o^xkwLMzSUgq>Xsnf0|yBVpudL>NGEc2Ek|(E?R63{VNiB<7s1ugUOvqI^Mk)i zkVh{%RAkAuM&uP51@z~QvKLtkxbF3(FbX`PPZZg*X`F?$p>8)fbKY1yiueHdLp z?s7BUCko>KGe>V5+%h`~NR1(_A17KN)xM=Orbye#Y z^7A+)))!{dr<=8EHJ+4j99>B@V=h`{s# z*YuXGEXe6fhch=htK3dZOwsh_Nl4hUOi3yQ3$kDrOvTQfKmQY8N1xZ5>n#DCmu`iVSooL(k_(6f#HEW*d5373=fFSvD#A3S9zCFKiG8w%bmE~4z|G6IJK5TEo z=l5Z1_Omq@!_{i-X#g`>>oVJaGWB0->Mr(wD*|zem!9$ZrJo{Zz@G1a<2lMzPC^m$ z?Avt!1|WI@@SDWze61}O-nXXLz}TZx_g;Mb)mgGSrOBpqgOXf50$@kP*>HV9C%5~J z8`+;<$FEUS3%Kr(Ruq)&aAvIrhn-6bqF+dYMFSi$?aBCIZjB0NU zxq0;L3tcB(<8EH$zE{(JMTw`tb+4h2>P*hQ&Q!hpjG^zpjsEp_-QxvWfnI8yt{x*o zOu;a6vq?w6e(zIb)^+gllx@%VD%8g|;+EPlTSR}Rp#0KAs&E$P^{QJB_Od|bdhnc4 zjuoXZfO!q4f2bE`6cKM8dwwr+XFvB;7f~TI)^x+ale99UYQFCC{9x139AE9!{cs-{ zx7{pb_FJ&zXy+YCVPT8p@EbpT%+0+nWvuaCbqpZX_ix`eq@!Nli#C(6ErShHK1$dz zyoD!ng1p7kp*as{^&J;jrdG4(Fc#EyGEiEh*#K>|%jWx_qZwx%^5c`WJu;opd$2P+ z`9b*FRogp?pEQIA)zviHL9Ge>w+%qIbx?<}tUSB@WA~;WGNi7n$#t-KXmc}gJCm~? zfQl512*6%9zdD0Lz|og;sZ=SocKkGX^&LNS$bNaqld(vh$L!;6Hy%jUPpB+Vc`7Wd zn7>7?b?hI2-@Z37Y~U17kgB)x2dTn*8lG>iPF5o7aL%zFZy7ftwwIw{1n{}{9&1*V zyl$K)a@>FZ@=Oe<`CD;p5R!tak+0Z{FImmvB}eUc&YqK{Wp(LFh=t@~li`0I%DlHQ z`oF^g;O~d({3plZ?79~v8AA<~5{<(U%M$jv6xkJ(&Kn;Eg! zb{^*T{Ul@8|65i^$Np5GG;L&sZJ3nM(LI05?-gyMF5H=*>Ly|^fC9E&$}v92MJZ@C?0w#6TUY|EL>wmAUBb5dZP??n4V`x*39M1lf5yJ zld`hAQnlX8Q&cJ3wZASV4Yn?nmr_?X8$OvDMKfAt-xTU^X4>m85R(AT0X+51nc14A z_fL+L$!-jh5Sy9Z=Rc8>cQ_=?q8+Uu)u=FQ>@k{=dFc3OGE{J#cWkb#tW*U6r;pvL zsoB2<%&^F+@-mmL>%}z_SFM&k*sVmC18uqwQC;=+9z;&izE<$B>ODdJZc3V-d~~g( z{^`Q2j?+5icgm1519p1==vR3MQNLj926)VQ4H=;L+U-*1@s7G&9q#ac@3H#)?%)4t z|KU26kY)DS6IdL(4b&%*n@(nSd*Nl{kz3HSUz6mL)1YmlJDyiNODl4zTucvWJpn;M zE$A&HJ_+*+uT29ul6}En-L?O9q|V9zT@h^Qyc{nj(A`+aYx0iCIS`1sE!=ng^Fl(n zP*srVGP>&j6BmwEdZzN>XrxFglCz#wA} zCK!1pzX0ChW!xoe)Mp2F=|Ud~0^A)yA+R7{Z8E%2ty(y=s^0IXou46PG2aUJ2_#2_zs3Lk++m7Q~VRn(O>yYQy6Hm&w#unSU>;QL|+>rupfI z+brubE!0-QoU`u4+{@5UeZ+RUb8F>o-10IWUk{QHCKV@R>$e3<;%;rrmMwJuSen4b zrRn@YdgO5q(QHt01{7c}VGEYtzw&dOcSN8<(8&L3Ks9%hjsQdZG#w?e{2?k;3;5P` zyGI>vJ2>+Z7$xK$h(_mdaH$?#5@{OvMf@{ogt3 zXKRsu?k@MJ;JJk_{w0PUXGEk!A4P~)IwcAb&mMdm1=j!D!-89)3)<0M8=6DcbE?Pn z&3uG|!SJe~6qo%j+21nu0gZ(HbVwD)ynDuZRL3MHvapGyKj681CD&m!qputzhUQQ2 zueEG@>7!fTGOPtB)(8$?Bbt;G+aNXQa0AtE=>w|G$r6xGBav_! z8N`<8V@l@wGH>e7=spq=lb2Dn%Vu1W(vI59FYd$I?7`xa*Q4CR+YW>b*L%${XNOZ- zmTj^xsk?P}lb~Ro_j|_mz=Q-LqP#%1@$gg~I@X_9N>Mzi1%cF7h0G==oEq8Mm{-BZ z>g-{;ac(w=-QGpb2_U6zyGv};h#Cgh4h%pD9`2riOh`+UrIZ(s()q*7B~;{rGtq`n zH1;zwaEAIwJ{0hViHU#=I%1uIp#l3O6O+8i+2CWX;+?PCnD>OaxjdWQ*2kn=@xR=B zZu9WkY;tN@=jy_wvJiWk;Q5Mvm-CPD;Yk1H8L!Sf3!@07ujA6{{?vFvOyHlF5&VZ+ z{Q8K`w3tH=S|E|y*xF;9DjV9M!~yaHe-^7+KFC(da!258u)lv=F|;l8DBdbSlZ zZ{ihD0~^x!agQ{vd-oB9;7$J(yZ@g#rvM{XT&6kyqQjPdoyvdozpIc8VlB`+5c024 zQpu>Uj{U$!+)CNE0I9>%%=RHDCco?;;r#yHWl%Lq_*zNHj_QZQJ@-MLTkE&&xGNsp zlOK&5;K*)F-wKN|`(vCTD(2?q)Y*4WfK3g2TTAnw(uI=aot~I$WqX%k=7Z_gb_f?< zwsnAIJO~@!MlkD-<{2N&G89q+igSF|0epc&Bs}e1A_nhpA6=w%4EwLSyZmf0uCh+^ zd`rtmvH5CriE9`mCrZx#^}*drrKg{q8YsE-Hg(2V9Ph<<6*)7{&?>xOM}UNyIkTGu6;Cd)wrij7~i>_SZG{?4~=KV+D8ASD<#Uet+eOe$61!7~`bhm=m= zwR`svAYWn_m1P^6HJr;mTFp&^bTU1I1VjJucIXX%LTAkjDrj-2=;banp6h#ZII z3bhRz8qcxjKe-8-^Nm2BpL(cFU&w74GbYjzNI)QLb}is?4iYPwmb?u*{gW+@73?kE z?=CNz9F<}0X(VzS!dGw*@U^0v%fQu|hRSZuTCtU&A6&n_ef|8_>8Up-p+U1j8$$#8 z=tZ2nIGn`~S;oTLw-szNWvYo+L)<4(NK-b2wQ4{}~bb1N&DnQD@ zfw2szfwzcq@dp5)A>3|_8vFNqwVYkvc}#=PJSCW*C4{Q^`S}fA-SmY99??8}3}vku zNR^9U>{CTxhv&!Ztri7w<1gD67-33)Rj>B+kH9-)7#a1~vYO|s=~Vj&h{02Q_f>%u z2;iDt7@tFj`H^;u)h3@zL9dT15!ewq$iesl64ocIwvFj$V0uofJfPem%7UF_QL%)^ z%~Vp_=2;D^x;oq~Lw8K`{=eU=*Bfcg$Fqid46VSf{O7Yy;_}E?vp4!49&J%AtAXO( z__z3jbuj}%%+BT0F;Ftr+o6F00VsOM$fubQIfF!Wr}zmSMJMlDo&k*Zuaz@{YZe8I zQMg$-NxE}S{c@yGIuIb(D=`HC(`*8X5Z81et-#gW_MvFhR^2l9f`;Z^?E7Jgw zp}WzCJf1!-I?dqulT2Lmfi5|CxjZ^vtfsRZO#2dZgk4f<$i~J{`~Cajsm9u|UDPOl zxZ=)m^Nt-maMrA%0Riuv{m&j_4C?;yMv8X)IoJx>{8p6p4L%02(-v;sR~#?C0T;dl znn;+B00k6LR4xP&8n6Ezj&3FR1_*V|lEc|XdN8`Xu|$v9S$QCnibzpj&9Ntljr9g3 z%hNHRtap@y8uk;!$RnML>%c=-P%s3*{R#x1+!LSlF&bFcSqMz>0H#51pG5XkQEKpE z?Co~kn|VOM9b*|HxyNEXcjNCt$OElq0`F_wiKFIZ?c%5E1co^*zEpUkdc)a|Koh7| zMe^N!)VM|AU29TOSZ?HNytEVfh4`vFpfej$M%?>WCN49im@HH3`{eIQ=Fhh7BbjJC zN8XY(@s|OqQJ?zW$6F8SSbO`J&@8q%Oq*wgyI( z7dd$E5Nk+#WSE1x9-%?9Q-(}^h7w11`H<^q?PZNqP{aXE>8lvy^S2`DbK|u?kC-bC zY>Az%Zx{hDw0y%1FYt-5$g=IXR=2+on8P`SDg7rZ-RMZi4%_&gU**;QOUcu^;@n1Z z_S%DC(_IY=$t6gX9Ypk3$5!~8->QE9?gu0)R-1*wqrlZ9nhMJCoWHpG2ol$Qgw z+26oj!2W*1yXe%9i&wF?V7*j}@Dh3Ih+e&Vh2!uJR>Mf{ucflK2lB1_aTrm2B>`e4 zt9QX7z(qN943vOR(3S12W?`sUURk=K%yDD6#`-5aLC(HNvJec+Bf2L@P=}QcXBFXA z03=b?p2Kqmc~hG4O(O7Ly!=s0MaY`>Tm_{a96E$xiwsh?M?rJK<>5Aj*?iNAN@&o=M0^`j^l&u94je_}LU#;# zjsQq;`@3~kSJ{8o@lm|cQ`7ortYNIUh}ktIS6tiE5vNSw^gR}P{_S6kf*2cc5r~UK z2{P^@Z(@emFTuG7dUiARMhYe4rYp>_G|6knd3g-XdWK?8eW~&?dp(B})xRDdcj%29 zE7eHm43IS*?2duLnQEI74nKvPd#No4o9Ap#4=+&)E(HbYq272~>;^Fm&c*fb)0q@@ zL8nPE2T;S-KA6IavO_m}I&RKDQDNRQrxG=vKP#8?Rt`NLW0_9w4?e`c@LTFZHIrqA z7BFW-iK0WoUsZ>>a~MX59XaJCtrVHnC|HM+^xM0Nq3)uGxO>9~#!)1;;#^4prckg& zKvNbmg=BB?sMP{G#>I=7MAYlR3YVU*94F0c)HeWcCiGsV+jd!PFGnMBqH@{EkKn1l zoKX2T6f_SF3mi#4VWqU;AJzsOSbrSiFGgKykurFEIP98ssLR- zu)DG5bhH6duju3(k~@_zDQly1uYmXDn-pHVHe1|9UZ1ln!BJ^pwjjYE0m6W?62LHN z|0_73;ka;#@aFHA4!0rDQqiba8g~gDRrKmE3VMmukG5r)5Z*HsbMj5qn2}fjCXLft z->f?hr~xW%Obd_fRD6P3gwFbug-l!$Z9#l`53Ja# z2(kj-CfHtn6EidOkEgSiQe|F24=B6rJK$By?(n zp>eGB6AkJiYusDQ#!&H|VfkQAhDkRJKX5B?!ed)xj4Yg~RCWAIR4STfYhE}cR$`*j zx1%8BeYpqvbvzGs02O*ijwFy_F(@+X7=W+)^-48=?RoaH`h9PJgODr-=mSxHLFza@ z++AdVV!RR7H|w07MowEef&@S&q!cMw)boj{^nk&1(dj=0huba(olqAjFehIsub;MX zsjvW*uKs5iKK&qo=mS9LQ0qDBY*(n*%D-pz>cnN6`brL8G_R^TFr)R)G+G3j&Au(; zJI&3LHkZtayLb7jrLW(WOCh6|% zhEAt_2vs$e2G9ZazVs0MfIF~#_lJq!zwcoQjGOo1-P+$Tfq~z#T`Y_h7NpEs5x&_v zSt}|DD;e35Dry^mMfi2_PJ4h}cw)FCH2LM*2-vXgxX3(G9~*_hNlHZ|U=3^<3U}Lm zWhq&$zkqX>&)SRr>eb-`B`Htq>)ofePWf178Im8|j2|t=8gAh9AnkR7#Z9LB6X@#F zpx*rWN_BY)rd`tpzbkb^j84UmK3&c*aPIdBhtl{DpHxuAp_#h|UOV@2MtH`Spt~Tv z5gt&GWXP>tDG*%G)<|(Hn^$!<=Og>#9-J4fg#OV!pr~}?^5wn0CXdqNEwPSZ+|f!` zZn_n#8sCOP7mDG@Nd_{(3Fs$=@B_#{T}U)7;|1}MHYY7)+Fo%+4H^AjE%=&df} z=F0^IV~2m@P>Bhi3%V_t=Ytl+X@@HKK4o$sHbLd`TPXaor`sJOCqO_Y2=S(Fyy0MX zX9{+4bK#*~X8<8lVK^~1oCeCthvGQ2Z*MZtzTM{Gw%T;xtVnqyvAMv+ZY7Z^Am>4l zv=7{p9_KGBge@SAT_?Pr%{JnUy>sA5!tjYbmogr$L^NU>tMBRKczB~8jmu-fqIPT~ zB?>101LM3yIHqKvEuh~_C9NXUerHzu1M4Uk4H3$sLPA3Ko0vk}uI@c@=+5F^ebB>~ zf}KJ%2&&9J8KO$b!xE=}+O$V2#V)|j1c`d+5B2dUhgBS+Py#FsstYJ;uOxg`%HW4m5dRvu1nN+ZWc2 zrZUBYYe>1u+A+56-zkWuLGnr&o9`tyvtPZ+FO0b?JceN_1-nsN-cwq7lnwP4%Ru4*aShmFk(QZBe?Xz8xg zJzj76BH)>~@x$7ei7l;BR{D%( zU%j>nDu0b0{p($y{Kzyyao|j`MbrdNa`~Py&^M>f9G-_Hx|elzt)LKu#Kbs^{U#wK zBydFq>ljC0K}yGE^>*+lu`c0f^0Kz}#Bn{5Zvl3;`&DCS&zo~2X>aJe_lX%MT0OA! z8a}B_eJ4FJJSP}DWEXIs5W5u{kn6Z*)-6Zvox7!VSs0aylfS-yeY@-7S=BTYp2Ydr zg3dja*NF(B-mvF(d;h#fs!vp4_Bvj}PC;K;W@dp;^;fW0mvja%4n88oCkrVd*^CbH z|9}Ee7egfwgI}GFzeJAF3K}PhKpy+hnQ4@hr1h7DnYr&|i&rY>_a}4Vk{9p;V1uZl zV*BSTIyNug3S)S%q1T2#lkw^7)1Zga6wAzXiTdMrk;cvCw`Y?`6OyAm%rfX)WxcxZ z2B)QewX`(sU8DC4`exVMDhV$yi(bTbeiCW)qF@T36a&k%o86()tg$iYnBJL@H)XSq z`mb!WbU4MRsC`v$AviV8DKZ=&(a;OeBKY`zMCBF+I)c_2{6fZt44JeI{oJHcn46YV zlr>N?IkY8ZZv^uIj#dgLYOx@wwj7>XAp)nyKEr7Gy}00Q1Z5!`g|j!iD_yNN?o{SmF_|$oFpa&r|IH zbCuf_4?jJOVnG#6MH3Z%s2I2u>Ns`?2ILJhaXq{zQaKTRz1~U1Mo;{#KW=avfJY>* z65u-q85cBccge)|R&irrE<}DK+SEEs^8M+SySLyU#Br08xib^Bc zy}XPs9Ct7Yz5~;k8T35yRyLjzmzO87 zJ)4j@rEM6LEW)Hv_Db}wux`Xk$-V5HCr*od2%LW!2STC^ngZBn?I}KtWfqSmrgD7l zoEydu^Y1&&`SXV@M6P0y^&aFGqeY08Zl!(@=d2zwdG_+&Pmo&5AvwrW%89}FN9!iz zD-y;L#j2{K34H3&G*f`vocyVD@Cm6@8}Iz5RDv*k@HYbOL~cV(hCk)y%a<<4kBW%8 zxVn;u_7KhV8(C&WZ}OPqz3O#!wFY{C*0}!KW&D@^`x3YBKhZaSxHsUEv%2C}Q`Eps z7^2f@3-H*N*I${}u9L;tPgGa)cBTDwvrN;=fAKBW;9Jag`_6v}OdPVuN;&Km>6`W@ z7r{I|~gpyt{u(AhM zm!S1NdH^rJ`*?t4#ZvJeWn4Ec?op_jKL%H@h+8CJ&_-rSXt&ZMX3BW60 zNvJWK)s0!oW?BF69o)2!Q)Z{CsvS;ZeV+`Yoab*{nG+kckLpCp=^Q%rc393{D$gXp zM)m}gyA)p#UEtKvj{U}l%@9#tFU{<`_y>C6yX?0FJ;1FdPPM7wLS-YEU6KtJm_*jN z(>*8UH9C5)EWY3u8oTzKCw2n=aM}Si{$aBTf6=?u>6pxj)La$z9<}t3Ka}%WU!s!j zAU=0%z$K|Ol5@pQ*Tw#$<{(rH*$s6b8tNz>suw;W_r_U68lK*Ck!^k7Fgc{ z!};#f6j&=@tdrC-9CLhcT*8Z*nr4{HxWS46YLIneVj4z9MxN7k_`iWIG=Kc#x$E)I zu*VrOtxBtR1YD7MlJzcSp+_9}NtAnNb&Z(MkpCS^nZpo#4^D|b{9sUj)C&3l<2pgE zQ>Z&6GdW_(7~2a`vIO)5Ivf(pxEW;U$j^ZY%SN-4w&%n>7i!Q`1Vwm{(tIwH} zlz73aE+pT6KkQo6r~aNyTpAQ9s{7z?HtHt}fY^FOmet#!-M`TK>jE+hes~5BhEWq1 z-NiVU$vLk41e27RR69x`1Ukk;@?(v+PiG%_4n;>tubN!DC*P;H_QmzxLDEmMn3Z1u zlVy*&^Ox*QaZs2UE@W`kLA!?A>%g8pm*7mhzt;n!7%y-tF&8O&bhHN5ge;O92nBew zOFaI%xTua!boygYcTbzkjZ*yQ75DE?5^nk&;!!POJN(Rr5weU(^a#WisjBO#R+iDu zS5zq1ei^&DW3qw=C)U=L-fP?8$_gYn@$+ZaHP?)tEeI0QqBBg+ESd76 z{KuX%zhc1E|GeeNU9sN|lO@wR9-~X0XFM+fY000e!NMS&gh$Q-Mi&J5?o_TIyH=IzK137gibL6c2JJyITK^@p?mXEqz@(MiV8pcgiWhjtUg2#FlSn$Tf`wUgAOFr>S?(*MC1GU> z+&;@=bN~#27PO!!v>30STg#-v50vWj3OQ6NS)}vg(Pu3(8aJQ8YVm5ejQ1^$I+uzz z4?4h`%^h{OX1}~}v>IM(O)fUO_Jj|nREyoc!FGNd)(nMO2BfGk63@P}ZuW(xCS>S2 zl^9Xo!EZm_J*RcfT(LjKH(2LL`yI<9#lk0m8v8+gi16=H2iva!oxSl#aU-%zDPoz` zpW$%7`GBZY!w++(-_Dt*m_+1u-`!7xPZ$;kJNam+?GIjc?%aW7TfNK*7CBgnZ#c`g z)>%K!5(*H^^|rrp$DjQJcRhEz6EL;$u=IP-f&p)k*vfx9>^K`U=hxZu%neT@^$6uT z$4%?2Jv7f+1_ynfBKMZRm|l%o_~dnM5U;MFz+M8oP@58fz>a!W_Ll~>MSyoy9iXFf(DES?biDOs9 zgWWp8GPWT$k7VX9IudznWqZvAR7>Rkf@ZoxZ>8@dM`+``e!smaAvlc^pA1xZ^e-%u z5LL5ndY)>xJ3O&k#?JRq$>DIC;sB{_gH^~|Yrn)Wyacek6VW$iHn>Bo(EzK6HS5=} z31{mS#Lw2l*$iu$X7xs{C0Xe*ZST&mQbf-0NmjulUK^rMCBUdt!S96fTzW&^ym><;W|Sf1JxEr}Gz!6`9%>SQj%Brm!9G(%oE&D5 zC4QAUf21(3D=A2{i%Fr>T86$McR2@yT@9#l)gqWwE|bADWQ}4gR+N4|j^h*u8M(LO z_S84ZulXUEd~dCoyuEhCsgaiA`CA?+)iglJMDPw0zR1&O&PGEqncRk>3NDCPH8}j- z@bMh#Tfk|@pHiK8ltqLW`r>4mz?HrGhO_#D6pQ_0zI7E9Mo;V;g_ke?Ir@E_489#f z*pM%h0p>DgkA`nb8n?Q-O#cpSofeg@X@JcIVydE~SQrnj+v%dZ7!q&*O>+pqX{x%5UG5FfGYv)Di% z>~n|LGpODsjrfIoy|o<}nH#~ktpU5}J`%V?*IT^F-=?c0G|TaV zsgdrv^gZVz7js*A+0GLQz*DzSJo*DCo(y<|270p?djVc9Uoz2r3{_Pw?q@h*z4p`F z7JQ;w-LOi>IS-RKvStMmVefNoR?%Zbq~q`H;~mHu7Gq2vy?;t?1})pv`c5_zXqhO^ z?3L+8oT`Zldo~`6EW4SKqH{3LMhj}O(TvNEsQhuj0QT8U6ED3TZT|@kp^ehFa%!ZW zhma}|xY!+jfy6>cbj@|vQrFkxy+Up8m_}#I6lenj5{Q-ljIo5iy*)n3%ndf!xQhzl zNe;I2p!z0afba=}G*~RY!aVl-PqI$NgY2GQyQRX?^-?WoC8RjU^wf}KbAA1uBl4Si z{s4QT_F8!IFb1(42J^xqp-4@?GTg?^%7W;yvy~ z$S#yej+#~Zm#DQCN(&j|M1cdUt5@F*)xHs@rcpWPbC7rMfbGxrc!$}t46>Xik^J#B ziByMxvXqO~H3645c}IAG5>mV6x7A*n*#mvR$KP9F8gpzM!(4Q5D^S{|H@Gi9{q-z5 z=nr>N8Kvy=wkTBPdBm-NHY{gp=q#GTPziwcyKi_SUywTD5+Om(!|P$T^v6Q9gRcCj z-0<8z(usr18t$5J{tFNtx{&jv_8P!>VDpkIt<9?D{XlXrGA=2Y9)(Et+sh}9)w#L- z6Jn*NCfBX-J^aVps+*|=b_U;CSs9X20NfybFj4kKWe!vKU2w=gVX1dCBFN`vx~yr^ zigJJvKY@)}!|db&Z&x3FW*ZH$tfLmL-ffM!wq)vT-(M|)j=V2{WkM+Eg^N`usSoC8~?|G1WMFqE&| zZEK|Mxa=(3e4-~i^c0(sEl28sltWo&I6SDYAwzOy;Xvt;kyVR&cFkeuK=x%`^nuzX z+jk@uD16!hD;6Eo=+njz^`Y^g-j&m#y)k}~i@Zfv#BTKf8@WIP^b1YCcZk-8 z4RSpS-(S|qWXQ8KgrlDxY`|AM;@PtW zN4_#pZ$)Futrb{_3XMGNIQ=s0=EWV5<_q$o-mLG%LX;_&-`Z%3Ra-lX5M@tNZaBX+sU`83`k6&=&b_&2pQJ(}OjV)g zb-(R(63NVm@zN%zPVve)=KlR7@+4wACqqaLtP~i}G=L2vk^hKH3m^n*Q9NTDxuM+c z#wrOd_SsSyc>+r+Ms}(yOvtB5)kbNUJmju_{h*Ud2NVpg@4lfg6h#OX?sa!dJw}%e z%$oSNbbS}_!!(8Bt9r`wqoU=DX|URU88~2S8;bLOJF-7+`D&Ck#`#FG;3yFzow!^E|frFtef>d7Z2faLyG$ zgVfG^k!1P0hx!X76WzgHPD$%Cj9aPjT5*@rBEEIPLJ?NmBNUt577NL?ggl-7FSo~`Bf=`=(k17Q(IP9OH~8_%k1#@*@t)f-B8K^v zD$zczIuCR`F-hi=I}oE0&Mw&XU|XbIkaOJX09WI>($aVQ{O+ePcse4rloTWpo4xyM zc*%Z{wmu23-wiPeIshtA+Qv7+c6UcG308qLjJK*yMJd3iA%JF}y;{Ye*$u-%$GJS* zXJXb!XnFm%wCUMm^KNHy%V$kek`jyv66%unF-WRg;8{#LE|21*84qrrZ+kcXXO6;c z)tdUSTeni+i3}xwcXuK~WF@XWS$H3lT_Du2!9umpZVlUGnUAMlU!YqEYrBxPcybS)-C#MvWhDrkkQb zfxS^yvtcA};HZ=O@mU6z4{1V5JjIIlh=`#WP)V+_AM1P^>q?(I=X@LK(v7pwEj>LB7DLE=4~_`3^ho2lAD=J@u<(e9S5A$gg!pmX@)9Lp-VRbBMjVc6E8KGMjoyu1w`ba*|T=JjT}rVB(M) z(E&WX$7eExDlR)8Jgx|ngQ>}$>7ieJeeX71PCJ+Opc(+M44m`=D>1Y(z?a$A-rg>m z&h9HV!#2$Sda@J^uf^$aevp~>zDs3HHlsvF)_5YwBW{>sb16*Su;acv6p0_;W%<`oB5nZj_K`%^{sI?p|=0Jc;k|?nCc)%doE{ zJ1#p@5eaCYPTLAO6vZh#wyhy=ANFX**Z4A;n)dDA|M(cI`U7G%VYFa%f1!FK@#9fN zV@^`4cxCrpZgImna=^O?n{I~M?M>3Xk3Abp&+bj#o5XO`)O_0(HD#nz`#Kdl@)nu& zFXF@H+Wv;>aR`N|{HZ5P8Oo6{ZSR^)@NB*be zkU3P0iEx7XsbSd7V^tbM4Z9fUbSe_MaW`yX-cR8QO z^gB6T!uU0h)pgD4eIfmGdF7O=P8xwIPhXn80i6fn^hN%9Vh7Jx~GurRFXaJTGq|B(0+5y1v2WW?d zc(R_T{ZRKM6QzPi_=f9et=04%)f(Vhb1Q5QEc`z5yYtJ5Y*IF@mvKnNh^{_W>O2K0 zVDtza;f558Z*bLByKjTRyZie@)~-$Vuw{NJRrF??nfIYGfDUjMBCJ^NFU1if(q)eh z-0!SqBL5biwg>u?@ZhZU7ji5@QGpm0gCm`E#CX{a?DfpBa8lpTy+*u7X5)^X7jCYT zu!@gQ`s$bGlY^n}-TiYuiK{);+Y=1?pr2T!A56X{ z7HMvLu!L8<xYKlmG@wwFw6DM0+B1m`v&nV;H@Xa^`{i z!ns6kT3a(%!(OuWDij^FzOEU6fr=hdmt^mAch8UY?7#JRxcaFdx(gcs1*FTT$_TF? z6`ZKWJxlC5?zUIwC!alko(h|b@nSTC!(XzsU#44>n3FLaF{ih8nw=WXqkTv-VBEKn zZ=B(Q9Hv?Dr|;ls|MV8ch-iBy^F~Q$)twRBm+Je=o)*)0`{-7(b}du@TlInN?s#81 z`V9U>6c#F{(Q$BOg{7tD2uEDA*uyhLhgs~~--ReC`*ZI5&fA&$s_@utJ-lf6ldq=K zZ6$CPDEkh9Z{FSb-6tQ%^e%)R6cwbgyyQCnsxjJ;8^^Dhl$16aqTmEniPo5|?HZfJ z?cI!N(c|mqo*vXDSQvDI9JN{)kJ_Ql^3>2)CK@EB0}i4~D(wI3aP%B9%ve|p8o|NI zq*3_a;;aO~Fp-;2YdI^(+8PrSW@ATKV({GN0BNGJ zHKQ)AG6pNpl8s-|JGt7;va-XY(9Gv12V2TE7R*D=jreIFBA)GchaU3`hoU2vi@2@W z*Ry;zBwz*GP{RAoaz&RTZ^ZAbq%2x0l9<@u{ntsY%{1#wt!&#pcw~`Z8BF`a9*@A6 z)3dE*?w-BwA9GG$(%jZu{huo2$=9;E^a{F>sjONwWc+x8ly;AxQo=XYt1r3)DrqfZ zZgMMy?RO1Wwo?_)6p8hNz@8<`#p1Z*LwV9kUlcy)UQ>+)O zHn+mkc?UcSxR#GR_UaN9Pycv}w`R|Ex8xpU%^> z4-I;xP(ZH^RnYpJecL3$2j_I?2JtP~GF#V!Ma1sh`DH`JojoOPe=;=p=8NHTybU(y zcKJj47E~%JXq#*ycuO7oS}rG%Rne26W82>{veT?|brK9BOO(cxJL@ z%0a}U_;K;?cXP`)M4rU@yovwfWY{hVZ*kPAZD6WX1BewhQ)PoA)AH=B)OjJ+>K`i( zVT6ZArwT~&7Ci9Hh|$S?4J7eu&-o54&R1&B&g2qF*VZ|ML~7D<3=4h9bZs(BI$LD7NpCU> z6Z+8KPc%tF9>|y%E^=b!&+~ZR8dD8P+$4;*0v)_C=d}IYez?%)XFaQ`tdrw};4+7f z+t*8_7c*XR&niF5(we>>Ybp2X4I@G2v*+b6UbM(t25)`>2mpr=OAJ@tS__LFAN~ve zkyHI&*9WV%gQSc)lEhv+mgD)VEs1jB6kNk2b8?<25p^4?(e2=-T8?IS?&OPoRA`BDP*;b z;830pNqD+|!FmHl&cL0Q>SslDKN~|*73$zKIV=zSRI^@r^a>3!h>$71;k~6*eQXB! z4LlPUzGA*GF~ViNa;4@g4o0}yyjdNOn#-)z08!y9KYY6FZEryY9E#VUiAgW>|AsG$Skh>YVA%m*})2_y&D3GCl8NY*EHK4be1Ejx|Laig|3 z_4`tw{T}}Kim-^5WJO%XRN(^QF@Pkn89h))RFvJZSI%KXhXlP?Or}N(26m+25bt4T zglXP7^tb1gPsH3=-k2fMJ%Db_4aG-t=&>am_f^?;$~FD6Y0{i5FV`BLIu0VI7VLY; zAJ%&x?uZ{J()9Jf2f(i%FIHbO{Frz282oXke>=X)q^4J&ND4 zfS~J#9)ECxyrO(T;1!LP{VL_5@(^8TgSQLT3}72WOuSfp@WLqdNtpNtu&?F+>T4c0Mv zq`(;e23;_t@(!7Xs(KQ}e>VBa@WjOQLx|e|SU}%83USTq@Hs*}d#%$PM%?EI8w4UG zn{FocuVSE;oH;)+2qipI3Emm+e=hkcf1+Kw$zE$$t#p><`6~_`)<-q3(DneU92c27 zTn^@KtujE7f+{iX4nK3aqE`+ukwb>FR5k=&&a&}WQTx7;ZwYSWiUSLJ&#u`U(qAL0 zRLZm9psoDzI|$CZSA1rY66nZkj|wTQnFG}M5M=|W+?!P0dgt7+w+8FiurWSjE`;|D z5)_7o#ec_4c=Z1Xkz_k;dCfj@A)GQ$=~Nw*`bextAfIy`d|+)xb={*!j{w6-FXfm3 z5mF*k)HM&YPz&&#ZepRrD)KH$fKDAr)6bX$lh*3&U*x@5vU_nofbAx+3jNGq+=t|h zex#)DCS72M%RWn(X!3ZmuxRmIxj6r!LZT~N?{QKkQ(78?QQ6}m(AJVLiU_j#h)eub zwRUbv$|CMHTCp{Suic4|N8<^aXE(T$xx6_z(C4-@4rU|>*))qZrL%DhWaz3sxhmN5 zJX#>l|Hs&vKKN!b@aWvNbLZ=^Tr-{E!KD3`KDtrz;bWg~NN>y#lrz)e|1kfEW+<1# znWL<`RHKp%*wRD6nqRFDc>A_!1lPj1k2f%Jg+zaTJy6hhB#du+`{?*UW0aFRl83`W zL=5((nizO}QMBn*iSj2qQ_2~K(b^C|c#376{Ej@U$&;0!qJHQua=0%muBpD~!IR~T z5GGWuwoOSvVDugt^8iIK6bYuliCtTU0F*dhfQZk5|D*`*3W?fsAVX2tYhT!u-hv|1kdC zz2w}Bu9g5bYnWcjahkwPj1)9TLE67(&z`quH;T2bd1!DhVblHBj=-rDLkhOBp1R<- zWOL3Xi9dfdbHWxzvIgvP%e8UmQk_`r%MxIr6Kun_-sFwO_mfiLk8m?n<_3JVHU4=AkUJf?8hcTt|%fG$V$GdnKBL1jWjVIsLdLdVM ztuM~FhJe>Q^Oh-b@mX0@sC}lHM#R(dr5tSJBTBSApno!uLZ|s8KMdwtYeZfA^3>I< zZwbC;gCP^TQN0_M{>bE5XvJWtUbqn9m=6~`lZTPT`(h$bmKOtarkz3Fx+1UrZAR;( z74L%3pdB9{Pe&}KNIx*f_=JI%UVrFD@z(`%k2aSbW#3?$ZxsB&Q#4=!Hz3EcThbLn ziRS6SH!LHMvZ{Q8>l`k4!^-EvE#C!|R@N{Wew5USJ#y@uhl`8!##b!v4-^~V9mPt3 zHXsT7hwOOqBo5~ff9WnlJ032-373gBsHPcP+OVg|TleuWI^T9EKdz`;n{)%G zrZBFOl(UYz_NB1;(DwboWPFCkP93~tce9KKMj+yl0DDZ_RY=!_zRwSE7VyI^K8B#rVfk}(%@uL2ni+}>C+Y#-k~tkJ*3Oc$TB`qkA+tzq> zS<+lSUS1vJ$aSB4?(+@~Dy_Gg5ZT8<#KVY#*vHX(JI2ciqWfsnu^GwWN-o*TCErzi*GwBp2e}`<_MaRU=VO9>Mc7j}F&zo76-PKF(tF@hs>y z^vPspWI_}Lz&&hM;0z`wv^{%T` z*7~j2)y%W!bb3F8CmNV%rKap}+^P0{x*e!T4&g{>0l9RKJBI=Vx5IiR7kt|BTA^IS zr5*#bI2&bepXpEkt{w!A%{{PYb`_6jpc^G~APm_mc7-xA#L?nkA%KC%eb`=dzfS&e zN|m_Uaxebo)<1Eisc`;K!+|jjZ-^XM_Uv7T5jIwAlHTRFbaXT=FVt^w{Ve+Bt8$vWTpG$-6BucS5(qtIo;Z9j+qBirpQ>z{rFMePcx{a%6Xv~Xrd$c z74Ti*DlS_Qsoz_9o&e`W;NXnZ853Fkpb}hxIH|>*uHg9OR@yaJndPj%wBr}k!M7J3 zh7N_u7&cmT7uliD`tI8AmhD^=9W8*YXPuwRz4plSWY_H3|4z6f*FFX72;D3}>~&(< z|IqD+K=gYg5wqE)IY?tdYDGw<7?{e!Ff6y0S%*0gI%;DmS#>fVEAp=wee9tzX|P}Z z%=#YFH`x_#u8LCHFkkeaAHIFNsh;r5JKPcp4xOJzdLBQ@J&`s##B_bF*oOVZS8MJC zN7wW$fc=IodZP72^GDfqc+3MMY4TMhUv086{_}#}Vmmw9~4aYMROfOchJPV?S#|p4=P?qQt z2?96|sXKAfD^6?9wo*{I@zCMi`MFyK7aj5nklXUc%~fH`o7~zU5ia?p+*!)48%GDy zu8*H$=iz=n^OaM{XM#j$74Ol6lh0q^YA`AOv~>?)4@MCdg!?i{fD)Tkj)ezEAgz3zL-Y;n@7?M+=&aanln%Lg#oTeeBy)5we5tgrU-GVdzsHSQ7X zz(>>qa@|HO4%|e*8EyB0@w|E#UHvMT;fo1Gn>17m;a>&7OO#V!U3)F+KUrnI%PMiu888!D&j^ zjbp)Ewqts87++$Xz5XqM!tmdXMo1Rx;QD(=1RMTVe z^2LLalH0dK97hvEMASY%{usStaPQjasSdmQlx=&LtRzhwGgGfDwd}4>f4ZV2L#!qB z!{b~0=mS=*&QS6xOxUAVJ=aDT%pz)mAg)6TeC==^6GQoSjE`7Y8T!Fm#&dRC2PNm(z?%-IVVnU#lJ-Y3oI!|w6YwnYd@>b5bjncS9R|;e2FA7Raq%37{n@xGt_Ie9A8oolm-}P&lT#G% zj+wZU>25K#Pe(p9Cx_d8Le z5Se)wc7lqV4j|=$0-)v#NDd{(h%Ar)kGwa5rh5P1M|YhxC^Sfiq!c33Kq5j^Cqsxt zGBi=9kW@-VqLb!L<_u+wq%zNPN@f|7$WS43B}$U}yteutzyJNO^e}?z)dOfe_d0sytD60{Fko6Wy60|FC=+7NXzzieFQ;!4UQfh$;lWoWtls`Fu z?&v5n*`EEt?G4vBbW#%>+1)zWIo56b)Y);!WaM1P?ChVAZlmh}F^Q&e39z~f;%J$5 zbAy&nE11Ph+UMT66=eRDuU9WUbe5TSE+EP(TNly%7c8<=J-xuo2#bH%Vb^6~rnVnn(qhhuz3~#(P&s(k_m9l_v}Y%`x@7%8 zO*@My3kHgbS)Yvbg^$89<7bIbX+Sm0U$8j)TzZ#svs490a@+m9O@fD&NQET z8wL++U3=5nI=YWQyPv`!|tK2zyBk@sdB(g zXn(NvY7?uX{vA@pYT6SJo@J)Nna7pcMmWXTX!F?o*B0ofO=4SPz1cdNjdKsjAS}3V z!fycz1QxxtA6be27CL4~`1) z{Rm$GP@=|sE9|kLKu%R?x75Ce1sz;Od0E5@-?^~TbpE`Q2q4jcO6PLkXar6&FT)fe zuZa4$pC~1wde2O8EJ&j1WUoQ%ghvW59D3Y@SCYSBrt)*1BQ_a`l z+Gw2}(@6FxTFP$k4uyGRo)vN=Ad_`qW=N#)u0LWN9zKmBf&rt8rE#U{JbqdGFhv+S zNT%T3uUas->hN@D+73Vr(}n74%NZVZq135-#!nAR&pj+E$Uo|~xo8cU6E2h~?RmI~ zsi-@rM0?7VZF)CCJn4tx{!4hLcLAB7phEmUzWhl_ZnP;v(J z*_Y1RDkYR=Tz`i~H>>`d37OB+pKN)LOF_D2?c(Q-tp1QWJP?UFiW*I~?8tCH&U$N$ z*P(&x{*w|G@Ec1M@bERIKjHaHd#C0gPS@u+tOktGj<$ZLs2>OK+Rebik5K?{6BHJN zq?h-3Vx$w+hV_TR=%E(g1U7o4pc{`@h*h0dJ;?jXR>IqZEKa%F{fjO}MhGp?=j2wp z=okDE?g!L1388H#RCcSb@eN=)-#0A0_|88({L2WydW04aR1RtWUhALSV~9sa_%~I` z1td#JC;9lieSV4QtyYI&C5sAZ88wKb_AZYL9{}Vd6CBi69T2)-Oz*msJGxxk>glC< zfr6Hg1KJUx=|ZkxY%GK>Vx98!3qerY?e(|$vZBP{C+c{ zGDz%Kld%_wCy7pmK9i^Lsiz`U?g9v4uxpp^QyC<^WRQd%)&@Q5g+(?vJ&$E>HBDZH z`XtU}2Nv#QXbSg!bR<8uNjGn(HzgDX*XrBsx2EGZn!m;hKz&IrOR2!uSQEfc9rRJ} zu;_B#@DY0Y5BK)~u}xK?=!w1*I z60z?od11dq3m_H)e-~RCuqWMv5&EI}Rl-};zh`b=2)&x;*aKXkoy}sv9+FY`53j&$Bp@VAa5Mg!=Cw_xPttFZ{xi zN}Ua(&=%%f5G_*T}_*=HWila-oh~BMSHY;}V&PJ`c;V0g~VVm!F>L zqnl6d2(JahsATIY?43@a+MI!2mb!Gcy?eK;=!;Sk=>A9tzo1kWgU3O^4Air?0t36A zTTV)=1V17E@4x?6DVRkt3ayL~ddP|{eIosClfOy8%X8@a?7e(J^Kiiv&EDx!bk}YH ziKQkxzz+>=$ZQX{zQ{v=(h=@?2OL`(%yb7Y&AS{;xor$e47B)!+%v9!=mukA^^K7x zT3XkL!ZHR8kRHZn4P0|h_+2kOk`$;)$kjh=>pl4v`u8wHb2LhD zk+FSr&h?|cm|~MNn={jg+w$40>cPPzX|W}F$IfhAQGD-f3_y7j>gRm#5?^VWWeA4e zbNTk(-uvjJvRcD^UYb+Ur8`toAV>;aVW4Bq)iWNjuZMQs09!RVImQD+w zvJex6+QW9?y*v#HpPw%y1#4SdTjjx3u7}jrnOm6-{xv_5{U9 zOmbj=U|mT=TS3KL#17(MmCV8<=LD|W^*T8YX&W{~MVB%b}Ct0E5{VgD^cKZEYUglY*IC$M#g`CMkZxskh8Hnd=L8B+P3kji^zn>d&7l zb+CM#0FDv>#*6-kf-D1aJ^>2QzBgZVj+>`A3?Ig-e@|%071(C3{gawScwD@g`A9-` zhMOnT4n?~R6a{8-NX^3jgC`{fC=`RB#t^^;_D-Oo00*dZH%4S;;)*;r)*#7yEGK*S zWdi4-V*`QfA`f(aj1Y?5zOehrtg+{)zWKd~IVi8y0q+>%rXuM){^glDY>|!+zj;pV zY*H{%pHl3(rjR2e{B`O4rZh+A3H1dgG#^U}EMHJ|EL}2wIy*ZtP^mBE0}eyJ*}%HeOU1J{!FvBz{*)JZ|4 z1r|W+Nd;sQV04NOFPP*e&NeMGRSCamUodxR@)28ux+!Ww!iem)6Xz2qEAdEc42_Re z2x6kv3qd!y^=d?Sf)orw558Wo$kyt>gZBr;*1SkaK#AX|J_VexQ!Q@Oq)+r2-$q~$ z`c|q*$Ay73g-Uyr>B)wlifL3?r`~LE)k={3BX2&862oa(8_Ru#^#!Z#MSwNfCUk*- z9>$Uc7CVJRU`wJ%_5SUA1-Je4njcN>2&5@|>Qpq#8)(<`;y<7T;W~Z3a zCr!z_pa;hDrD&D<6oIQmc8I!|Ad5CE4=&hyEPwe&Xy~bZGHK?3KHcnprBReaL z{Nt#G4HOI#9Bl_bkNqtl_(biq$ z(sg(-)qsWroKJi|6RDrlk`5z)3KiQ4EAz=OI) z7xs{((ePaht%?gPw7o8SFI`$Hpa^IbJ3$0e-W3=IAQx0U%KfREW_ze;xoMS&fsGjm z-!vD&FS}29JqWp+SFSygJvEkQ_y-5T6QY(BXH8W#4QqY2(2gu#sDwtI zdr$S*jV~yx7Ck!oY5!nvg8^1so`zWni!dHV#%F~lS)@IICK95_%eKIU?t;oelhhgc zu3a+3C_wXck&_FJ%cPQy+~(#pQeea54htKv<6W7?!=KYSbx`iO<|U8Dku}js=%CHI zND5`R2<}0da7$fP)YV>AsB`c~+k!K@mJdx7CI?8!vy0x=$SSxm5(!7&IsQ1-FRo(pA?&xDgOaqFIaGY|5jg427 z-KVkOsT(OaH>;{5Tp41rhT>LryZ$LzwIE}t8!I=v=Y;MIBM`Mvzx&H2U)ZKh`G9P12dZi& z#=Lvo;{=Y&o*atzUA*xgFH^?sMf|OZq7`pd91Q)Xok4rY$9)(W0w|&8#3Jm;s+?wg ze+Rthvg}nGyyma_kUQq2epRq|ETo1R%e=ElZpX1CX(yEC^0ba{NcVsnh_Ut(^9x3j zGt}5rX8|C-4;Od9wXv(v4HTde$zAhO%EUPgnq*+rCf9r$`Rr}2Ff``;mj8aRJ7XX>mRt9bjL(P zP3&5*s9eC;M@QZwOa*9q4~1Cjp3U63_ugDsXo04>9drymYz+YkIkN;STPF1wJ{Co} zIY82s<;(?YLiUg9sdR42yx8yhJ0XI5bTSK866!xbEUW$Yy?e68Pq7tVGY{EslovSu zsygN-H1;uQ70!JceGM7**(j!T14peRqc-HknS~C=hA+kyW|S1C%wRt0kyA7D_qnlG zTU*v`&twkNnT9R)rN!eW@ohL3GnGpq9&`Tn1_^b4KyYw+X>agDj<;DV_S|F+$%7q% zTV^nG&bISrLzu$K^%!|qfYWs6T14sF3R`-4r6oR-9<>*iUwmA4&VuMu*{2tnnc%cO zPCqv`no5;_iomFEA5co$t})C=t$XHi5qnnhXF^>^7IE*-yyON#B26Ny@YaZzdddA~+UGr0(-oxZe5_Nzw6H@Waaw zgWJP?B`*GVAGn10xdlwWt+KQJURWs4s%J4oJ!rip2gJou5s7ET6}Y(Mac+5+Xx9T{ z!xE}8XEV3cU#*J5RmiuP$=0Q{Y`y+q$myPidkdykd#smC43`C^xalX}A*zqaARHP!!j*=( zUS*cn*B+4loGvPKp+eu>)x^z{ECy}h&ml8?x_$h)y5@T z^mr3in|mP<^|`sv?3|KPHFLJ|oE~;*U^sb2<_vpJy=3b+&t-p1nI<1Qm(EVK?IgQE zh}T6V%8VBF@NkIRxM6A)1GlxB_0mZvtyE**w)IVB$QFV`6A@D4Col8-V{5q>`lcYV zk`Fn5@nQzlzSlVN3SiyMNZhsg0`@D*&gs@39s%DsZ{{{L5!LSr44>p0gq|v3q=md! z(~#QeG>1RFKOxt2qlgxnlq79pa-5U-+4f<>7CNqu??-M01s!niLSUKKFSmC3_>Cf!X8^7wkp|Htt zvd+vn^5t_?RFBQ_1s5LK0A=*LcCEZYi-&a!7@~_5HdNXpCnI?dwQ3#2tjx^h&l}vo zKOO?4_EnaTBINJft^N33O-ye0xZ%aW>8Y7IMz_m}0EqgV!lNs{7Odl{Gbyl6P zZ6d0N63cqjR97rtzP$No+uDsii7(>*E;*;rLm$g?A5P0;IKmuu5U37oUB%+H^6m>! z_xzT=M~pgkEy<$+Gc=wEdvGiiaZg=u&BI!89A*I4uRYRMda85n#&w|*YOtTfB*WZ4 zOJ+%4={i2U015BFPH@ZD*J9|K#i~`e0Rm?X8U5G!wp}CCzKqVqb=p9Task{Vq@6z> zBz7yYSD}=DV=}izQR>i!nm4PheW4QZ_F`SH|NJ@oPGta|K!c9UWpjnDRw?cCJQu8Z z#)!gnQoq1DD=AHUi`W1di*ZP_H^A5gkX4lC3#iI;&pO}0+v@cl^3f` z1Z;1tpa;0-%kCq=6LmSs==YMvFf1%(o-<{drXN$2KQ%;st4oi|!{yI3CL98LNl|X$ z0AvjFv=zd!HyGJegADx(Tfw;~fBJYdVgUZYEcby8$F`va+~57Eq=9P12s5Gnxp6`Q zbatQ#`e5MtWP;s#pi z8B5vuQyJvoddT3DAb(k~%ai$mkZA<0D+S>El1zwoLL@zX(fK_;4-Oy*u!fLf`22K( z@_75fpP&>_hc^&BcA>%n=F1&uo_MCOg~Gxq*G+=@H7x7{Sjf zDzvF@3buxoDZ}8})rPB1>ut_$_P7-;6aXcJDI^$|3jt0(0PSciAR(kN^hvMl`6t_a z*kvGjz6nz6br(TTHlig>c(!opinIX+}+m=E#`$QwYi{S<$EEO0pkH;0%R z^F&awIO{yJ<1;^qZgiUx$3Q)TX7H%$7GXnmFAVq5QE%^=nog{5w10pT?aCSHt44-) z_~CY{i-A&e4;LjFKPv=ct~QFaeORmou(`+!+jk}1u$CRvdhtMo8cwGpYqk4}!!XHr z#i^)n{8FjP_GEgq%fMA)C{v!x{DPX_2Y_2l%}t)vZUq98@hYcD8zWM0+ut=A$v*yv zPd6v7h6tOE?nVu3>F!XC8?~IW6ghMb!T&^)^eU+Oh7h6CkVriI(}Hkt%(r1@Ixn5B zSIHp-$QFbHCeMIx2L&YSU=#6JO1u#P6-~;4s0?|OuAv@;wDlNdmEaF<2N^guLfbm{9zfQH~84dgT+$faVvjbZ~f!HaF!LPm7fP= zcu=deU(eIHAVIkR36&72x0~?va&i6!het?$jh3bvN1bK@oglUt=EcM4DPcC#Ic~ju z8_%`w+i<|^i=I4oCUh?t7pEXMAm4Wwx?(`1l_>&$uq$L1?3${56jWoXk^^i^dDV^q zOwRh`UV&HIHG~C7sM|*~QQq4%*oksLQ!c_T)P0MMZU`IO*u=k1wF~W!JJH|NCmHwU z(%&~;-UoebhkxQ~z0AL-*VRxK&9L9LcW)Sh5b}L#1^a^t`N6b&o#p&^rnvj^ZGf<` zC=ce2jaKXrVmS%tj*TeQ&1Zd9(xPqy7kEzNQUq2K@$M%Lk%*~C_p3{i*{&Y~W z^&o50_MzNO%(i}MWR$v_o34GLv`ZTI+_!xz=)p2%puuMX4~qm)Dh6?{O%O1x56DMh zgdKMbtq{`FRMJ#2Pf5v$0w&;Gw1K0r`}gChNKjU_va)K*eURSH7x#T97`o*6XukSS zT9{93ad1&dV{*yWgRn?jv*yM2`L`ws3Qk!--yY@zr)1_h5;OfW7iTbx*f3kF$a}&h zYO=5ybZVr&2cm9hQ=RU32uc$TQ`6(yb668i*c0j#KHJ`7!v#zr&QR$p)ner~90`9< z_EKEhdJ%UJcm12#+^ZFhwFw z3@nl>0ePlReuWZ=^=jEv?6>Lx1bcu{OZEpr+d~;MRpw@jt2zuLgeMF7Jqo5^0g~hk z9B=St=%X!X6^D*X|2c~p0XO|c2vOUA4t=q1NV#9u!5S6}QA?6uQTYZiC-rH2dYmj+ zkVvj`c>7P5^*YhrJm`f{C~&&;tpi=io)k^|2ZWJzc-|gP>1|QTqfl=2GtXk80*#Rg zMNt{AFd=kxdw~synzmzctlghU8Y8Hn{YaM#o1u3SYLuc8n7H-siyjB0ti-gz;)Jr< z`0@F_`&h636XWduPY{cp%~HN({?O;SvRFy6x%*&u9dMz>(NNacp;ag&UAm+k-@ahj=g72oHa1xaM=|ZSjqtF8KKFYSB?P3T#*Zu2VIS*>2+GQtTtf zhuZHj(HJZGM#lrEh=~vJAeufLiHfJe*OC9@#|m4ND_)b8|JOQD^9C_hk2j2e;k4iL|)1M#s3lJb4AQlAEeZm_us! z)|^U0nWzm!8u|)#Zj@D(KV^W$OZL$x{KiL^!e%mNv#DRZ@mq^~hJEY#sOO##YVh(_ z#q7{kQCYKdI_^!G$t-4+pLq1={+yE17&_WVu2m;kYX|Idl6Zw;9-=%5oS$##)%o6$L-E>+rNHsL+wpQxftt`)F(~m5I6#8!055XRq8xN zK9nn0ZYRL_|oWDF2)*o>XW8*rvW2 zeeKGu>TlgI*XR|@C-D`Tf($2=ZL3mH;}Fi4Sg69WDqDy{pr>&%YnWabIC^5z^9RID zMUf@mNM@_C6_ zgdd@wLHpH#(FMQ22<&w*j(uu-wS#5DVG+#p>Kv*sFrk$*W=$K0sEWE5+K?ofU-tP0 zBUgdKn0x4Y6zaC$N;O9cwY7XzRD$(wFL^^BO6n#&wjJTUFds{TK@j;FK_dVc{z&&} zfG#4Awnbz(p~U1pmGjt+HoDN3Q-56-&_@h8vnO>3o_?OXcd$G_oNnGUq^G?x5~_g0 zHYeHdf6QRr7O%R_oHP1oT2)4-p{r^XFtSa;&taxW9gQJRNv=GO8ebP0Y zPM{d|bP2f~>c@ItuWLTOV{trdIa99RIr?#5;nY`;o{Bm72qBI@9JTZC;lnrUj3I93 z5f%}dYr*=`<=_ISlZdrBWo60u<8fUJf7XXTV`Ix>?_Q8a6itFhRQ^qXtXGm9K`L>b z2#Si?K*tb$gIeiaq&UMV=(F`^=lIopJUnRo%Za%tR87RVo`0NGJ%r2sicvRu@` z0)eYtVr2>zmTVFf7??V5flfj49thch4q=QK`48k61GXrf4Ia5iUxH94iOP(*p@H|H z1L=lxqXrZ-b{WuL@7#@?;M&A>0=(#}0vnC6+mrFoWt(PnmZSbx&@|X@qKYL$XK40e zQ8xI5CZVT+%LpRv{*e9j3x?~VaZl(t>+=z1V?R!#B5g(1F_?eVRepeg4E>R)0S*Ow zG08Tlb0oUhGzEqP1f`bpABxM2@AkNq@2HN=B+Hxvfh=wd_Zjy}q|Z-1_0 zebL&I-!ma#oR=4x3hRaYXfB`%MA*rB<$p$@($V*S!==fXjPmhXy^OpUw}RW6p^*_G z!(^86FVu-;?q6lPGrgzh&NSGiynP$-_w=|5TR+qeMYgJICcP3$b+W#n)33NO_3%y9 zkZc~lxkVTPia6pzLjUZ(McadNY#T^cP+cvd44M?|dZExITSM_YJcJPLpOyQ@R~{V| zXm(ZD&Ys=1jw~YJi@b|z@nbaAY2VZ$?mK^9k!T9wLpLTi8TJ`c+n5IX@4UXUD6aed zbg7f@N#C%+2*tQxc>9*=(kE|V;q9V298nWc!s%vF5k!QAW04w>Pe(%V!DU#oX`2u) zW~D9+;oajvWx(Gm#u>dbqp63q&m3Cqzfo}uGxvT+Ie7y=O7?St<$&7^@k5~>QHj!9 zUBHCCYX$OjqB0?Gk{TabhHk>k6}CY_oeUjKmMwU$;6QD|23ie*(lU6&Q^(re(V?LF z0DkiJLGDgnITIx0VV1>uB4Jagenz&(H+A(Q^OR9P<5M*Len{p#GR{uqwFXd;n5NDS z2u;qnDk^e*C%@g$@TQcMzxR^P^0*<7G}^gcMoM2s+6~uP-*VJcGzD-L_P|< z?mIHb%Qg+D(4vwNIJ%GZ%?wdk9N)}85B$%BN}`}b#se4XLP?gd?}Ia3-j0L`%GD>J z4DX>~C1&|J0{M40d1R2qH!<;?2U$yxjY?R)y8=W$WMYKM5!CyJ2S<=XQG1^k1QlU5 z&InUseXEWy6b;>%mWPlE3+yDJd`;>wpUs2{yz-IGEF@ejkg?PZa)@C{u zGiqgrlJMu8CumZ-bQ#vt9|ttXlY zk;%%=Hkalj{t^}2Df_KkZyFWA)8iy4YdC+s-SNGw)h6$j;n6!jw8o+DVb`sNtb4>z zxLC2SPPRs=wloJ@HJRQYzq+7BXPxfTVE$=;u}(tP+b?rGLt!Y-n9tv%^L3?`*jqEp zYn-$H{BQ-NR=l)S!p4us7`o(jG-gC|`7MWfp1-EquO9!oz2xNa^pKIL%>rOd5ct?0 zKe8^c^#h~eqWoP}MC|H4`!MTp4A;>p&6{Xc+r@m>9jA&NiiF_^*z}RA@vjg>77)0Ulw`g z%AJOh;UalStn+0&)-j{FLDKlhfDmhRlY|4z_~ z@p$(L+*O5z5YShZ2B3hhYjuzNPf@mM8qkUyQJc1WiUb{k(RT=$_SO>%+^XJ9l>6?0 zzGvaD1DOZ@dUMznGWwPJm4AnQVV@z$0+$)WKL2_0tb;Pr_~FTKGHP82`5d=l^@Y+NIHi zp`I|I0NeR%s~tbpNOrfWuX@qig_vELCF4J2{pq7Jg>P>v$O^Hj<_!-~Qo=%he$5?v zkNQlYo6;GX(|rW~$KA3~hgB;YKVIGH7~H zn7?pgkewMoyVK)EnDIO5vw|MVAJaGwBS3~D;`mSLPaXC-hh5(w;EKjJ+QzE10~T7Z zKOViY-Y2?p7ND39eM@yt{ZByfe-FhtfhO7y4IH?~H~aBlv`qhRIzj$#Jc3O!p6BO9F@g0vv!K z2c$~6NX_TNwi+h4>6r?@jz)h4dnvnL+yem_Szg#eK;82R@bW#hQKELy)Bp#zm;b&< z1=AW15@-#Wd8mmR!3nR5phtAs0TirB{Y3Y9{QG_e_hN*;%81#CpNqmvrpt&m3i~*_ zu0ZRA7pQK8LylN-SX!Nl*f{(b{QDA>hqh~vCfp5sNb)}_BY8H?S*@CWv`yN)n0t}j z(arcmV&vWm4vt6cAub^y@xTPr>(rMI;p9tm*Ji@G1bgCI>vPZLDgxJX8F~Bmtu#DO zV2sw@(2SO!pq7i6#k7KEN?KUkoXmB?;Cr%>llawXY+8U+oaz|52{ z4VKe`1JSCN8z!8zs1|^TZSYZp$k@lO`Ei9JeAkhK#bI4_ZonST>O^irZ0p}INmYc5 z@j#V93N3Bm1mPR3OB?-Wq-E_5WZtf4Jz;ssyG5ZsTCu%vI0AE_+A|GFmdh3|4$bN% zJuJ$NQan_b1D+oqv` z_TT;eb_0JJd_@mrrx+2n4gW#6@c4t?oC8=QXZ$Nxq$>$~FOPTVi}TQl8cgFuRoX`2 zU6*n}?Sa?tU>#I-Va7au0akXvx^M<#&&hP0>Y>$t8dpvHvG(S$d{tDY-ZyAzYo|J2 zi5oHADDvwg^p`Lj8jnmLZ>=M~c5M|JL8aOmz!sKYk(HW`zctKeS!Ii0LVA0kO9P&8 z4XX8YFX9SiQM1qK1>aiU*Z`#zBI(67tVha}`}2ETy#pd_TSe-ab_={}ki&hJ>LCq_<`g5Ln1JJ%sXSF zM*jHvqcfyW{tb{X7M@rvo2(%q0o$mucj^ipz1ka&psHKl^_UuQsi>;nmN7+fbsz^G z?{c<{%pRm7!zrY?F%1&`D0M*K!DaI-nf6Z^-2e19Kl${(;RkZxrI3*>%B<)$KcOxA zrnc1s%*^_lb7%?Uac#nbRaV=C8An~EnukDGkMBDTGaDAfG!96PKQ~b^nhyxj+Z#~- z4ZYuob|4#IkKAFKYE!REWWvYl6X#_l1!zBs>j*YB{CiE9mY$xdns&n*K=P3tZ7aPj zsi^v~bU{_m7@Ql{+K^0*O*8T3a!BxB?alVoi zZkXXSYuvq=Hc$V{$I=H5JtHJUQb}Bbq?oAuKhEmKHys9*(_;v;^?KlXJED`RQCk3X zr6o2bxAlGd>(Fkz-=lR9se1;rWsPY3Cj3xQA&{HqMZx|Ly@F$4B>feZi{%G%}} z$ZooUQIsw)x)Fi(hMW}Cw{3ggU;v{S(2~oAlP4@oI>vNg*-0&vOpRlpxn@Ry$w7V1 zs7;iLiV8Ojj-lKm=72%MpKrn3C)*~}QTtYm^CiX~X!MfG7B|c)GTevNr)B93C+39MP(wvXsd~E>f+kK54WRTVr}u;B@c?@x&7@t)i%Hsz23gS+ zocrQH4!noVn{5b2xtn2vdn9JO(9b%23ny477M`9>L`DBUT$(k%L^q>dJzhi%2;jbZf!D=_M)z1J{UZ_8n4= zXogz<$&AIV8NW2wj+XLN4)Pv?*EV_0Za_hUn!-`%BvLD5mx1Im0_LFayCHrM zK(Awtz`EH&|VL)vO9WcgIa)vhOop`{v?3&5< z{a`NGURLG7a?TA{`^cm_G&J<7BK567ND-WR8^Q!|1Px8ZC!BxC-^!|UFtiRC)PlH%e=uYN+D@Ez6a z&x5&Wa&%wO458P6Ey#OccYU3ZL*-SYye5L*AqPU=Yh1w|n_R?=E)78KbuiQL$&)8f z=JXJ8C?wjY>qXIl^?bGsAy0HnQ&h6Dip zu(V_Eb?j?QcWD4TkklEB(CPEQKuKypiYYQzCuDlA(H{YlMV3L;{RO>?+8e%NZpI?P z@EFqgPu`b4Iy!m_I=s}|fq_=Y0x7rqm)n5OxBtGTOUu51z%B|pvW|um01k*gy6RDX zt(#}up*@M7xw+?Z%taCess(;C5I)NO`)S6j^TNx6-$SKEy6~LYn{d@+4+Rs!ph8Fe z#S`ACFb56lkiM~;G_hW^_hy1m^92KtEJb!*oils(4LfH|v0aQ~>=*emIm|I==%+Yk6tfLj~CySi(rTz2_{Gm?CGAbZnjpA|+MUKyB{SFz_$a3r+{o8xvi0vP#8uh-D!CJ3d4|PYM{gV)s;J8Y zS=v@XIS8eU1Z(fh@Q2p5 z_t59k=)LVBByKaebGH=-3Uvbaa*COVz%*V`cE1I(EH&lBTD8H>42df(!N{{;h;^KV zI)A_xjgA`boy|Pa|B_1TDUkZdobF366k9i8M7MBG;fp7$DaAA2KVTWJXh4!AM|3$@ z7C5|ihA>mq&aOYJ7Z!Qe$Pcy*;RfmE^y2N$D=I21$wlDztHo*xpVtj|(7OFGtqZ$n zc|!-*0JfPtqDz-PiS3}_0-M0rtX^bv#0%u*<>eWn?sVjn-Y^8lFnXE<8%J zROUowgdb5`_Za?+1y@z3c6`zL8Jd0idd0(^?__`Gr0y$ezoEKWPF$`mB~dNr!`>O| zmWG#x7afyax_SAc=^E^1={M%i6_b`R4{GCX^S`Mo$048iCReHN+wQ*8(IYtzMw*7u ze*Lt4b7=SJH+F4_BN<9{9pf-hQSL{yrF`U4Y5zU!vVI>%OMgdc2_eDCVKrfD0_cfrhr9 z-~9VI;BSM(uLB1}q|?HwTSwf399<0P2huD3%PgK27K($Y+Z8CV@ze)29Cfmkny{=g zuDxyTVkGvtO%teuD4Cj-Q7^i72V%2gKoh0&mZZt+ybBY)OqOep7WZU4O=|y5=I<1c z9P6w?#u*4MY!t=b8%$+vNQD3Ub>r31JBFgWA4LFz?&$jS_mA=SpPnlxPIlLZ@bC$r zW27zOn-In`{?ET&WiU;-b^fA7_dk62U{e8unoN-i;CI+I9FFZcI1hoOc--B|4A-T32W5iF5;)!Nyn{UGo@w^?brq0P#bNwPZu<>lh{pK%a09s3CiN$9 zs=KI&k+E-j0_^@!<+eN;nIDb;bZ^I9&qt5F*^lIBIxcNr~L$UqP*kTg{iXK z^M22Qu-SiKhj+=%qpwtCcR^7KY~0t%^(@ zHTGjFKEQ$Q0T4qo)*5W1{TB@IK95Bl|H1UR7pQu^PY-BayI9RTUcv0n<{4!14kVl; z69AT%K^wy|l0M{2gc zfE5ZlGDJ9b2$`7`HJhPf9@-LoUk8%I6OVt_G10dWSvwsbK02bs^zrEz7V%cYt;&Tn z1Q~=teb&_e(2coY_`bqfy z9HSMIl6}RF)x8@nbI%TiwDKiu-`4e>xqv-IR#Hn{^O(&N5Hxok{>6Mj(PTQREBd$x zXm#h^JG_$lHhxu+iG3pX?7enL)@A;!uLr>qx&Pu99UBv8&P`w6C>TV101TRBw0Nml z*}>vwwe0LjHSZp-L)&$k)^!*UsayXY6=9BOi(QXQAj=hXFI@u5nS1Wib(Z^w*DQVVnL^yXi5D(R;aIex#v&V8Gf~QsIUn46&jljyB_QjfD>JgYss)eHSUH zDkR?AZ#suxVte30-e!udWa|M!%m-KlG=0x~KQXXclfVF^1-Ea4aLQc?Nu@sE9qW*a?v6qmIk(9yQqlvnepW={IM0ZC!6NQvvM@b8&g<{lU=L`SHO9_IU84Na2?9z?Y4mgO=B{``^APm>J$WC?_dV z`UpdbVb26C@Bwjj%I>j`1zhvz&fRak7)D&Q6Z_gsbW>*?tU|Loz*AA%xWHuju%c0TRA9ovDDvkAo zk&eNYdSPNx>dSOvk0pZcEY0^Dz`(6d;?FTN1Kl91p&<;hqw%%z4e)75z0FIwW_@{e z;Cd%$t2+-Kg#GL5i0+=OyWL+eOd($kwCcI+&cq%YmWHebt&{HByc|JmH{?ry`ad5e zpBJE!uj9F3E)RS|S`y>XUUvLsx%Z&tUP~<~-~<(iIuq4zkZ3-rsi=4U$-TR87AmS9 z@D?JYPBC%ulJdu_FDgPdiI%T6XIIsOeYrhEp}u8j-@ec9i>Njh{}QV2TJWGFqoVkN zf$+!zqoVuibsNy#Ut~XwqFw?Ku}=^6JUnI0y#2s&@O$Xl?`nWjbm8+s7BG?MyX8#k zcBgI`I-F z89Sjct3jL-Ra#oge?9p`;TzsvAq}9R5M>>4mL*EY$8#t|@yei96Ho@H?uI{I25ND3 zdzXHFht76Lkt!_Cz!a3kj&6v$UGG-17WptkLO2A@{cxaG2oM>UR0m>PVE=aN;aEay z8wh@=Vg->P5QrD|M}0aepMWw8>Yx$aH~8W1b@U`SGBx_BHqf>tQX}-HTQKhkJw0e1 z+jILwF+aZqIEt4pNfsd`_4qW3Ts3oQIHH4pJ>+%(707x*Bu$4 z=~epfA?|1F5g3!AckxEE2Utp7@APAfuEU7F{}RJL8gu>6;OA$M9+rWnL4Cg_n_I5d z^5GUla5kDG9f1B^=wdthkH{Od;Sv`afB>fN*PT6h8-jRpgdvqB@@cblf&R|USU`T( zfZR5m{1`@g^SZNdX9V!9^3BQ~7`oHcv|@O$j_KsdQN3Rpz zoCu5nb#m=1`%a@05z(IuVrG*ex39u*#C{>Rj^p;m!O#gOxuj1j!VbG>e76nTMwuY7 z%#ni`Ux!DoFF7s>qh}v-(JF{ymS}5Nj4htcx8mtP+w#+mc{n(I;gaLO z>2+-l?i-b6UxBT?&h z^xuo~wVw%h!H_ZwPlVvs@1NhCx_pI@MX7!7DTGPfY)1~S4$w3RWHKr5tjwFpq& zJPK%igtQA*j=PD6QFeg1b7Te7M?{`z7iQ)&|Hc8Oi^+_}00 zT$|R8F!56&-bF9u*#9v(ij!fiZo(6ZgDGhH$x^_o_fZ0y@AZ`v=?OeEUqVV{KH!f@ zP0~#Yi8(YW0*Ve;uZ_}FK%_=@^tY3@ZzgTmy&lJj9l?W4h3~j}Y&)5DrhC|K7Q=PV zBkPhG29AFGPsy0}cih+)h!BDyx{Goa>}SG-2Y~Ez&zZANXK5h@TOdq)5w&KMkJ0mis(R{yag83g4+*zU8;Qg>HTOTJo3fGPMEWGZL1G5pMn29WSe& zHEvaQt$7rQCz9j$Oubm)oay~Vq1aPji8XU@fLWLOc>n>0oV2DXmX?isIMbd1c}O}t zddi>>XQsTv*I#sdsHCv)ZpoqV-@A5RYijPiG*>v72Sea}Xpv3#iX}H@?wQ9Yv%AxEyO!4R-G9(j zXAl2&((?HY{{957TWwDcJkhVXCAvdpCPc`X*F8NKwER%##|2qIt|D`N2IL~>2?}}& z>+!ix4%)bTHX%2TZ#3xWeU;R)CA zABd%6aNqzRUyIJrPfr3_deRvvJi1_=TXu22hX$}3^c^6R+cjlllgzGpDQUSD3}p$+z*JAI+Dzv zH*c9*m#F1Uq0lUep&?(Ml}r`Y+pKR+#}s+}upno!Aw^D7dkrmPoxXdH?C`o8y8sA( zB{tW+_A3xSi6E4g3^W+Q*)q5lXUt%;vbYg3HCn4^nOM<7=f-Uq4^&ab)~D}Q{Fjvb z!GPm)cq{_WViRK2$(^iB?snLM;CS7UM%kc26rSM_T${HUvxH|nT1_)`fotU5GaVG6 z?{3@)Hxy{<_HW;z7)Yu9;~qg8Q+4UbigE@QtlA(lO-OCdoH<}*1k}F9BL4+R0dFt@ zDZ_W>H8TOz!al$jyT3nq4_{{c)=vHxTH9!0$cyw{m8v;=o5tgQg)Jvl3d{vj)Nyez z4mRg%b!8M%G@#t%T?5MLw@*xH3djtIuvaU4c2)2D0<)N%9_&mc z#scMEkrAi4>Mi8Mia<_|sI!YoN@`*EK7M;VvJ3nB()AOXQtm?auf|fgJv_nw^a`)> z1thKZ(9fa!N6#Lvi$pS{coI<)5E6_NzsnYnVQlCdTKH5=FB(>d2vdO)SWiacH%rd8 zPcT`F{VKY#P|6+h)-O~(MyB51-4({6S z7Dux)A?IDlZDC(7QXEEJr{^pOI>F&#xpsxV(k3zPr+d9{g02mGGNn0#=;q+h|GXX4 z+@06gnseWc3*@!AL?BR#W&qZ7Py6Bvo?zQhLt=g8+NBl)x40T+R{6I`md!%r-ReDd z*^%F{5Gy!W)jHt&T%W8G-1IuB$f0B4>xstn##+KXR&nY{;CGERk+6V*?s$dC4eO?y zoT>xY2Tamj)bp_1gFEX9Z-Ff~zV&k_SC1m-T$S)L{s4F%siOt1&iYrlQ}ZiS!@ zR@IJQG}1j_^A-z4<#pzX2L%;x?rfQP2Bd~zBRxouE_Tof1V6diuo#B)(BjL7W@7ER zlAe5MBYrXK1RT8(?5Y1HTzl(F;O7@LtB*$1WTsX>nr}U%dG+#T@453X7mi@bFn-?3 z!9ivNSkQ!u4z9ICdu%e%UNpK^atAO`$fk6_-N*nPV?GE9z^1LCGQ+*OU0_zx(69%{ z?6GgoG&xiE_7BbQb3U!%Eh5)$+$X7E9JnF5rTcOLHz6YHrC}jR>MW+TQI&w&4rcND zq~~>YYXjUYrgl6$VbyqrmsY-(gPeAUWx>V}(vVU`V0~FrN|pLaqu@gXt_|4K7&_9g zGS8epXlY@X6!WdeWZ~>3$u_$aGoO2vjDM3OY$^dfC^k4cj*Xsbtk$dUuGvw9BAleD zkGjtdtC|}~Do^#S@q52=SI=#}j_0wC7_}?7{t8{aY}vcw3RDu`eyGmWMCsDf0^i5r zFKX)LLeorilu=P#G&j1^U!lJ0`Ax1^X8E;+9l?Y#J%0hKbhH!PpS){0;Ly&aUypS5 z>=s*B`}tjpt+dpiPn%*LWPaviMJRMQsj3Rq;DaBHB_*wYETQ9b&u?uVx<5A5@K!3I z)oRlw-&k&E8>?-%xJ5eaod<&X=>FBwC}711$-q4=(I#i=aut~&t*d}VDU#ajU9gaE zasuDJQy(e?{|cp|tn!XIvzIuQ__FQU)0nC~og-N@dOBzMr$j@w`@;8cfS{mB9MG*1 zm~?r$)YuWi>=#zhG3?6#;esnqfzl#d0&X1f2EY5s-x?qrxPwJZYO`4LtFbbC+BYx3W$zEAaP|&yiqR4g$rLB}% zdlq877cIt`Og`~JgJ5D617676oVa3%@`{$4H22zj^ZR458vXeX)oRLR9e`vd5%uWQ zDJw8IC_knV-{;W^I7wkXyO=+JMhaE+{V$ntFAS{H~m#zOQWz@(}}< z;eoTFoZN2gcaEEu;#$&{J+6-jGwCoG>&yscHE$u0_er9%uV@;18l!Y*id8fFvn(z8 zaz}LX&za#v7k8tLy}-$qNpZ;0I8$!OV2}duhIZ%pvyyZl@r8Vnap-&EE3y0SN4t<~ ziX44;iJJMHLl~R@vsB zZ5;K{CT|%U;7&eC+jK+v#xfNqEt9TEZ^adOB|-=aGPpGuJiEHldg*>&?$}v(J;A?9 z{51CMbGBkl7E6x^m`n0LsX+j7Zlx zKX0x_{Ed?Qz5;)=n$n8JbSjX** zy#qWr7SD0$$I(Z;8&4%+|ZU-&8Oc@WW6{>naO z!A;1f?_b_ynU%YrhyKnqUq@~e|&wdNfTc47D3GnjsZDNw;?Sc=PONE7v z2OD8X2W_&_q3AytVUX>4Q^h?Bhw--y2q##YUmK3xX_>w+A?C>Csb%?H#kB2}ZY-L7t`u!GzG zXKweB=p)(sZ72H6$DXw8EqXS#4CnpIH!$!XW&8xFo`D{Q{f5n*jjF7+HRBq;Hl#Mcw;C;9N=!qiqjIe*N=s|Nx6g10vutBl>1#FA?|oU-i^0>{Xe{- zrTJ+dK4&Wth>yLzm@-FvQjXk`IkGdmHcr14P9p+mKfhPYMhoDn7pH(b zPC-aSgb>tUUBxodfZa_~i!p8$sgNso^!?4cYgNw1Fe3{Os}r3&SxK z5zGb@Sar}ur|w;_3ZYgFySgzkY7kj)Xz5=7T&EZPI#qE+v4b^)Fa{w*VKzJ_fx6?1I4B~=D`sD-(n;fpD}zTAD&;r8y<4@yCoo0Q_F*B zO}p#5z{Z-KGpDhXY6Idy?;1VR3_~oEhAEz&7_FTcJQ(=FZ#uv)I~pRg)wum{k|Zg= zpyVCpr$!4YRWj*;`MA5@dT8jH9R;FqsN}z0t#tmXN zSt2k44Cj*%v`zFif0O=4q}O6HGDF2L=K>sGE!kdxOFZ{GpBt-M3)^JdVrt{h9kO; z;mU)_8y?wo+#oxa@P#S#TB-IghFn%=CX#=`8x{tZ1h7wQa zBa=n^5(k6(NwUN|hVe$pD+(Rr31G&Mv)OxRzsM40tNKTKt=-*M zcH?2+xQkV86Pge`GRlP8?I7Bd@&!-d8UyP*JUqL{KPeOk+%r{VG9&E6QG`uUzbhz6 zM4LYlJ>Y^!xc>iO>rJ4k-q-)}Em4U&l}ZvNq(tVSkdi_Xk+Mn3keO0R=2Ov3Bx8k8 zj-e=12$hheWQz_EnpdOWyd9llCbFS;vH1J6Qh3u;{&CmAygZV|zI z7Mx;#U%KW!sDthP)S(ZO(&OFXySVkIVq7f;Kx3VL%!xC_gZ3Aof(O{g zJ?6|AGvWhsPY(fQ0rBainC=Z&<@KF?CrVSWkd9*^E!DyK4*Ukn(6&Wu47)zJ6`A1% zuWF2jnu(wy@CgNj=AfG>;9v_&i#qrjjatRQnkE_yfpb7X+E8X8VcNTME>&zuOKb?W zxOm18hNERK@wvHDzkNGgH2x`7u@^J0rIfDDXD2pf=9)swyXuxD4D`T@Bd3EHC|}9L zLsRMrv8Ww$h^F}!~@~7spaSjH7J_A-hC2lnPyKw ziIRXhK|OhUwm|%xjA;{O11&E4%*g7anGKXv7#AT1c%mIf5VjAoySf%4aYzw4PO#CSnbx(Vk!MTQj!KFQQ< zR1kUyj8jscgVk`3xZbNr1}no>^wPLNC<>220QvzFQD1-&zDWbZP1k&+QQ&nD#P+S- zf`){5$r7LHA)I=YX_lq7E62%{^y`p&UWRNEoB1YEFNxKKjV&TWr5rpM>Sy_a!RFq7 z0jB?>;kf|~97K|a07~yMi?JVIRul)Jcp|Jc8pRKO`8EI%cbV70y@9*mM_3AD)B{yG zvLUx1bh<`CVf*&&G*ltC_0YMQp`|-1{}P~0jYB%hW7t|GidWz^yaI~Uti82Tf7kZu z;)V$)DRT%nGR+ka?SkVAgs{SnlJ=w+U+o znvTIE&l7&l_QB*wnzln_FCxM)9;^C@9(42d7;Hsf2QNc@sVIK6#T$fQhll za2XW@oC#S-x?fNc*|>}x9Y8wXB*7-A_kyL1ut~ir_89-fGW#f2pMBjeL(Ua{7evC{ zY?5J)YF2-b5m>pa0C|TW&)c3yf9F(;QBLev$ZhS|A9g=Ejn@`*_0?5`3x0$);srhf zkvqhRVN58(A`Q`CQZmUKWMorbY3dD&6D)1c+3WbLWO)FueTO+4ic53zSl!Fw``l!^ z$|%SSv|eg|E}|@lac7enNQwZd4qqUW3K&b3nvK0f93>WbYb9PD6^yCbc(Z8q_fUom z9WQQ@K;n+-YEsd4Rn~AH%$>8=uMjv#{GtE59`H@|xHGJ?O>oIkSQYMZY32EYRuv)3 z2(qqc;x7zWuDH%eXj#cmCrsf$cGuIVPwyw2AepldN$bA8zW8Jw`xIlae?9Ec&ztlH ztBpj0-FI{n2l((zaxuSwH;bJ!D5ReNsNrcv#U18#Jm+hk?-yBVE^DV$eUfHD50sz$ z{_Wd%oIF&X|NheI)C!Pt!^Dw5d`L%~vDa_FFG?ah#rEao&49fYpB-WLR{zyM#(jX4 zau?DXoh)uqMyT-eZ}$hia%RX3Uu3@cLc~{c&kQGyM`9N^gL|{J@W_ zhG+N@{u`xa41c%!Xn0aQ-IpByx?!xv&h{8`59@Aj7doN&a1I4xqo;V~;EW|mqsZxc zWppqRF#7^^zQf&L5R<=r#z>_JDKTc35Ucwq&lH_1w$|)<{05fW?C|Tv-?20|i2~6k zRv2uj`+anPN2xUq7c|Y7+AMN%o`{HuIIMCG>6o}Pj*8hB<5x}?(PMr>{NmmCw-_!9 zM*keJhKF4!F{p%q(#tj*d5_jKfRFR$6h_JJ5q-P3c(z$K{jS>hy?JN4tCH?WL%P$b zX(W0|hq=ri8~9UG=8e0rN-M!V+<-IKES)s~0A&;F`&ky^nxScJm?52?Yyv#3uQlHY z6ylK$vbh`u-raG%^i5~x64hV~Q};p<;62jM z;YApJxkbn{U2W(YE3={Wi~%2Rb<%RgR|2S+41BN7gbn19LhUGs8^Q>|V$L zwuVwQf+Zn|zhBS%4++6KK$LNj?ts`O%_2++a4W8!R7k*Zu5#UgwdoTLZGt-@ts!Ey zX#%)aKGKX>HT@XN43gWZ12k?q8OEXBTw^xxM5Xo9QCv{ccsAXd&q_4xAy|~sf1Oi3 z*jblyrAKq)>T)*m`*Y`V)qyR(wtmvd{_Ms}U%?}iXU4>lb_;r19$KN6v8+wVa}*nLNj^ zEId7Z>%1_v-Wv%}Gf9z@93HHP4(UMo;rb52CCu87_N( zSW3OT21N7?V^>k;A~GnGa2ka4Mr-KEgnADSZES1XvF$uBukoEYM(Zx^(>Ai_)Os<_ z)Lbx+MBN2jM3z&(i8(@5f}`B_+i>- zgMtF2uTb=^f|-V+5|@`CF0bd4ktfaJaNA>V8?xFf)fZKDYc@N>e;#TnplrRm?2m}4 zKY#wb_f@N`!DhT{dwYz`;9VTk9?oce^RGZMj|0L6JxuI|N;N;ZVO!`f>qIFqqPOde zD;sw~a|Yp|KjRU}nv@@6%KW~&QOhW@wZH>6?AcI%e+J}*##9(3+bYITRt#NHsJf)I zr=gMNU>H$t^YvW?eNOHsDu{=#uw=^>}-pEzaoC&(Jb zCn8hCAA9@snf3SdL<+bqMvHn=(6j53L@>K(nXc~TZ=0CWg}!52w7B~p)}Zoi}Ay^#WG24|#-`;(V9r(r546cOVzEH}+m?$oJM_UOJi)&>U! z1))j44Ufjt_V&G4M27f|#`Vu%e)WYo>gqpcF8NyU--b6k<@9G@%0r!}^&ULfVSKr+AXf(K$L%jF zR==MN#ORP!7+nf5hy1nxa|Kw7)DzMu8qhY>`m6&LB9vDIrDN_UnHJESq~itC6KOyL zQZRad`*=+!Zs8Oho&1=`DP^8#*_hA9w+2H*0KvT+AL^Mewo>8tOo*_x&e_?DKm8*R zVjO_hN?7=EbHb^2NTAsa9xHm!k&3D{#oOfAW0O%$MjI96*h)m$a_X%0(Es#m%ke%1 z_E0t)`vU6m8$v0%0&!2q5cuqb+zE+h5_|XV-BQfm`WFDhrPsmNe|&|p&A_{CEIh6% zUR!_rK#ptU71hQhb<8t7^n?dR-3G+IQvYve8vt@ zNp&|3iq$ySY*6^@nxy-6^{j)7&pO|=l}TY^7}(KuYsAklVvloxLai@D=L9&f7mC4M zIK*NHcDOAEi>D#jJ@8HkmJbO!waM#@$j!TcUO^BSxOZK?y;G_jxvTcSWtLH#eVaVPG53Y>b;sl#A;_Lgl`@BIY0(z$* zscJJR_HfjtflA&<|C`!;c(88)6dn9p(SC6ujmQbBox-q;Q?*c?afx?1Nkvkx%?1$y z=_~U?u$wu zE~U|nM5^v%pm@2UyOS99QOGMXdGj3Hq;K47)L4qpp9MoD*0SVMnYE4cfaOMZMwhU< zdV4i{N+@&ds+Ux-4_Vno&*hq)=Gypm#XbO{93x9gD zDc8Z>OsGYw0!AVH#Hj}u5+`GaiLh{Dicz1L(ERQ^LfAPBOJ-oU<(2(bORi5VGrO_5 z_TrL}^xOky;RWJ^&8TzYf_6m^cIZd2D7)aVKRo`;{&$s8@BpX&w?OX7T_hOLX6{Ij zCLex}yqxxxfhZ`-&&jLIn3W?i+MidAH$)bRI;hQzkzytgfdHpbAc{#8xIsL!nZ_8$P(c;iNTjHm<2v?18hv4KQlaUlR2{xb*!6@W~OF^88J zh-iZk%?Ag%-b0B0uzAlYIN5djbLX!1s0}>1dqj2ij7(L1?K^doa<;FmWmB;2Ul)1h zK6D=|>4hwizTrKiE+br*;cn0u(M1_dSMQ#(ruHTDoXM~cnS#vSNU_$xbyEAiy zrgKc?{cwbox+ryw0|EjFg$&0e;o-bjH@7=BVUTj5NqXJ)TG6Tp!4DolWzs#%QvKT$ z?n@9&;neTNm6*vaM(Otrz5I*I=O<%SRoYv`_Rxj`lP|*yWLQvCH2xz2a1Js4~DetCRSW8ezNC?G~HX|pk*1oys-^c=1WFATP7GTom0#gywhNPavw z)T3bgj88Lx4T3Nz9v%$)`d+MLGgowq^y%H}Stg@`+sz%7Mib=bBETYhvC(PB# z{g3DK0dv7&%y|@lN3$r?e~h+xgl;@KkchUDMAA6z)j4#TB9$v{pLp zy9#SN;cHrpf21Q|+Z=eYq9QL>MBLJqiYB_+A=tzrf9)w8HYxKwCa$}~KhY#~?k}|o z%5?*NxhDb*ltz}5`-i8)C4Oony8{+G?-2R)&+h>pLARU|6MPC2`&SPszi<>j<Xj+HX3CVrTjKVeo5R2NDWxw`V{YI2dhq%q_|^!}+tVBh4NJ*< z+3Uyf&c5~bL@q6Rndc1n&#vN!>!^6Y7zoL83TMPw*aXNGOX${cx-Vd)p4&QoQ zUQV$ntSKEWURfKD4?IRH$IhV-FaMUjND`SPi>He}p(dDy)hqS_UoydU!L#jTLKmUK zlrET^0}mFa&^)9fnlY*5_2X#S{KE&`?j%LcbGz48lyqtNkawPGZExuNr&&Ko&o7dT z4Tk_N_bqq@7z_4{jR9EdV|^YwpywL#@$vL|M5>mgmJPl;Q{fo4Rit_*vMDP>ijxt!Kz}Z3>%R+Yy6*RS&AuVJ^ioajculw?j zCK)Z;W5esrYCoi2^Md5@F!0C~f$WTuVZ6@2=FUw(qqhO27339nW&4)g=3!_oJN&6` zrP|jLcEAw3b9&BomxU#Y{Aj3&vTD9@Rfk6-0PtoCh%3qxtRL4?dXosOb2n7C9oFIw zxK)yA4wM6V{>P!(Wwq2xAaamd0Z1Y|NVj;(TX3=6soVNQhO@f}sNBShtT785boK+0wWn(o` z3Iih2TNJXZ7H*eSRU0~*mEbn;NBRu*m4-%XpXL?nk2Kei83gw9k>$Q4CWdDCun?no zah$#s| z4VfUo61uUnMHWbeV#1f5iSxROsy!PhinK6ee-*`-+C@N+Bj&u@Dck*5q-nf=(I z@~iX2-_4yn_Z!^xaP#0)qJ}Zxj6od-C+8=e@b{QRJJLKK0v`R}eTLY2r-Q>t6!(l! zrcU(t@12vA(zgzFPWtg(4q00EWWkr1nFfg%?64iwY^G^2G~l4RxwlO%v3b`i*?57S zT~aBatjv@@{@uI0mE2laDnBQhZUSPt3oINQr0TE+>O%+t<(=9Sz82vx|9|wyljD8a zjWii1W*9{*g}xA(+zX0j!lHCS~qwMkHTfn?HS7;h~fQcnO93^))GZ?Y7ZY~#muvL$eO^0gEY?Jtn z95k2>c!r!JuYm>_qa8RT!b3tVvwy*T9dj7G%* zRX0GZE$R1tFdp0J;zh1$0FX5fj*zmraQV(qmm-|dPo69&&ir!b%$4VsTV~G6X_a9w zNv4UrKpjmS5#NI}{~fqbx%E%I+mCs9$MLt*8>XLykAiU` zL>&+474E0Q;EJadc|){Y2kV)_dKFVqIk}++Au$g-#9FiBOCLSzjMm|f*!$$#44$a5 zF-=@Q^zE`y9=!oEsMu}*HpLW!0(Rhsa_her`};(aUW|ZW+sTs&a+Oou?$Gcinm}JY zj_qy77idIHI;0HQ`5ZJ%oR|$lDE;3F-|P=U&}tkUAy2ESsydAQe?ps+gctV4Asw*Z z>wNbWVOtnm&X6m;a_qh>M#kCKh9?K0<9EcJG*0j)*aK=!XPucVk)q)~D}N=oOG!FQ zj9bqcI8oSD-xD8S`V)LboHArO5zKpb``puVAU=U+;eh)yo6Nt2)?~X}%{^#0HfPQ< zEiILiSdBSuP~=h52TUM~=?4b~rB&pdIPr?)cjV))X96~%x#RAcfWwr{j~~BJ33LE6 zYaD#wl%lbU-1;2KoAEF3rYOBJbr>`g-AeSP;=G;uEk{Ng67EPBU5m6Es!3LxB4XO^ zBo>SvDP;@FLqDe9GvB_{NpbJc&Jeo4FOvHXcL|K5B#KzDTD+~AJ2Xkt^QCZAq#UT( zL!ZZh>Y^V;N1oIC%mA<_Y((Lm=DU)zJI}yZn`IBTEelO zs(^h6!&}6(T@8ke1O4(3_11D0B_p-CVis4 z3_oNe2#|bb#QN4v7_y2XaTJw(W=I2E z35_PrcW9Scoc!bgeVsY|d4`cu&pv--Ow00^&C3v94Mz7SP=@AKhj*C$(TIzz>*Ggz zx2%m~!W$vE@z}mw=Ct zfQ4GcvfzT&vP}SPbqAco&t!Zh2^=5M(a61}3=6`Yf%f+7#=VFAc7Pgzd!VLHojeKr zU%cycp~WK6j~^#hDex4`1?4>umqXB2@6_IA&*}CaW z6)WGVA?tuB}Nnwv)Eic!lbu4dBRRK73?89~9+y=*RfPz+T zheRq$)D=o}qca+Ot**E>~F=l>!h!M)eOn<3t~8O5fhk9DK~xo4^Z zu60bCAMjBO*?ZKbrem@{7(E*Xir&Mejnvm=BwQf<_0C+EH>%FlIss-;QHJQRe_9_D z?TI2th_rd2BVItM(6@GB2NwyaL$;HB4q!}r1GG)_>1dWphw&+6vIf}%TzR59KJd*R z0*i~uoV;Fu%3dKY%&B2Lz-ZjJRVABBvXKp#frHE}odQY7Pg{Bh7l+{>N_aACnm9t@ z@B%^Hj&8ywd?2=Rk2j`@05#l-#|~+dLB-W|2O0WXbS8Nim%I_1&y|_y;G7T4Sud61kXL>PaJFr!{L~wM`xUlMRtSrfX z?+5);xz5SjJhem1^qXXb*>S(6a9oJ?wtG%%=KLozU}M(Zv5vs|N0t;5I5qU&@0B83amgmFO$H(N>LlXCBURj! zt4B|ONFa_7g)?6-#D+y9CaE3PhV3$_%~M1I##FlrPZFL4IspbrXb>m>T*JXL+DZc>%Tc>A^^jR zC~Jert7={*Sg?0YCp%8e{wy@i!#f4?C}R{{=?ySyenSfj>6e=(@Vs=htucx!{R-p5 z?$14kJdJkW4=PtsI`y*=$QE+AtWYLAT{eg9K&6MKCYIjLf}_qPfB_hMaC5Tx5_NB7 zGYEiUogvOr@hy=BYJegQ1|cno$9NY@h>A@3wVHK4nG_nm5)$_sbHmSK9QP2fyh5C^ zDcTSUuZ$Tc)DC2mqV${)C8$WA9TaM>sL;l|4}J)t7`(PPo?k)4l-@u?i#d8~m1n~h zx61ehsw$_3awuydFsd%u*8c3Grn3h_H6qL#}#dXkV zTSY3CQVr&L=K<78^6GpY!suFX@86*gI(4|C!xCk=^giA)Bey&5E98!$ zdgp<0ZIpl4*8epy*JQoXD)w!TUPWn}aAbX=__yK96j4n>&oWk&zWr~=n8o__5G`{k z9{*-{VUe8J_VQZPW-nODLzM$DExS!e1h}zXJh`ze z|Dnmb=sIAtdhUSGjZfovDeiqG)6AXmRqi9pEv^afCC z$v}!(Ai|^D%u~jr;?YX+hG z`AD6$q0-=TzID}%uu2i~psN{69f-qMLBvDci&Y;49l+%|rF9N1twCiy{6cefciwCP zEHC3fc2mo6vYT@0(Cy|sF|cK1qgFg7^YLLW;A@Azi|f9;!2QxSIC>3mR*^TF1adsr zGjVG9BJEcFmR6<*I5u3s74P>nkUfAUSK`Ri#z)U_=GfbwmwE3~-+I7xe}dJ}(!Bta$gjf6e3BtSJEn+~ zjm&fN`$I?w>6{aJvorZTF2gNy>|CIij_csl++nt$pTs{rKqr02bG-K?g!oq5{sdQ< z7{wMsiR?vCA)?O321aFNWhq>8>R&?JB@r{|iBRqC?6ew+1YRjFBC-jpmnR(TY2sf! zj%K*5avSbtXPo`ZYt+E~y`WP?SfL`R8uVK}e|*9j>x`=0*=PCBmO6v%f9mm0q#?7; z%rAG9(~02Zeu2!&)gE;xPioJZBM&dN!Fik#n<457u4kgw_$>@A@!{c<)*!IAp6TE~ zZibtXexa*;Qef9#XM$_A%S{Qm9ElT;V7s-bzK7Y1HXRWU>|t!p-Ck8^a5CP1lUIXh zeIGFnWe6nV62(UbzN1L;2j1NlIoI=m84Tm3mxv4La}C=6C*?q`__m?;Pmkbs_<2M* zdf?{)1YY@Iy%Nd*gJ!gu{7NoqU{CfK4PnAG3Wy_c4CgOh)bU`Xzx_69=3Z=S6GA6{ ztKU|YD6i0ueKCZyAV)3C?A&*S2x!JXVt~vmY#nDocibmr;%hZHF@@L}ZzXw#3gQPf z;vWk-XzAh+0Ha968Q!Ft3`PuBPB`Htma{>$-vb?>;hy&{Rr0&782PfL!Z%R7i-wjKwcpr++%J);1(E=4ybI@r zp=9^?3VqaTC)-=_{E#*r=-8=p@LzQ~&St6EP-@*7o_aPB2Zw~R@@{;@a1owMm!sRm zaEpntFJPx&6e6w=V)W#_40#%G4AVh|` zXN;ddO7@!|vKPg2xm`o##XsoJ@dE3@d*+IqS}CN*6R~2-f*a1Ws=yJEz`J~L867DE zkg`By&4XJIz!i54m#}{9oqhqb1I!fobjautdA5flF=K`*&%CSy>pFI9JGbFrM99*b z>X?~1ic-%9U4c%Dhk{DEhqsrSjXNF&`9~d_G~PlO?OX%^Rm`8SKw^*#{{B zE$-Oa;9PGjem-$Y3-hl-zs;{z96^J?KhV%1^W#8Fd16x1N1DfqzT(16&fSmh@$q`d z+2$REHP&q_>Cwrmb@vydexF*)($g&DoGqBfYJG?`fqp8i*-24(eg_|((5F{7gW(># z+IetcjJ#pJ&yU2DQ&$RaMEo7UQqBb5oPD0^iaERWY`?Dol~42N0qNcGe1?*H7%O$i zgOhs$eeUn356q#5fl>Lv5bq7OIktV@acU*jC4MJ^T5_-1 z%ZPst4K*h-NFJT4dXT#0FnjTND6+?jo$XX4zzcYdR|*OBE-v~Br_gU@B}Y>~8u0t@ zMk%0>69`6w`UBPY4K%l=E<4Wsu|H)`@Xar)cATW3Nt4?a>6HKRUItU8GD-i+ZWNzK zJ%T~u<8pZHuKdjDGvppMkaz|may+p!U_BLs^ARQ2#x?Vm5cJ+_vts1O{0=BuJ==HE zpRwe&(M?Oos0AkyI{wGJ!cA2Km5YgEwTP$c&wI5~ z*z={PjD|&ipFG30>*p`kdxuky@{Y)gae;{0$lL+^XoN1Do6Gz=A}#iynlr&Y?JOvV zSOA2$x0e`;U)*ME8&DGP-&zqBa#AM`!(39i=~pFpY3Y?pZg`p2VsX(_dfSNut38p+ zANsdD^Vy__ax>~<1(?O!Z{DmLFOpTnMjtuSH7dqcfS@C(=MRP#E3K7+Im&G%T6%yZ zy$Gwj!}ROCphTK<9B5ip=%L%Zfzn$0-TmpU=H7+!*4h^v53^*ecXoh>JPw5o@mQH! zhHR7&3=!+v1D%_vLik@+Rz~s^K-l~C;gBQgE3eRu86ygECr@PtF_-lqNr_Z+uwY=T zuhl(kDCPQEv?|C64SddOHi6GrfV8v}lW$6F+u>lbP*##t>r8R6Pw(iL?k_TMorSnQ z7<&RV1EnT?1{j*e*Gjpnz3uC(J~AgSSJh>SfN)iR=fz3Sw({~VG*kdOkL_|NmJqNE z?u!I&CcP;sDW7VS&OJ}t<9OsOXaB2xYsm3gR_^!ZX-%$fINwK$sYq5AU$u&r*fd2{ zGIY>a$(tFSlqss-=E-Kb8Zemy4$IKQ`Jv3JLmnG0{(V9+Y!PxLVrNOSqE&*Igs~E) zBp2#^FW`rai)I3mG_iUd3tIw3F#9|gxlUeqg9^<(f)_guI=h@En~#MN0_&*c$R z6+}dbE_Qv^Zs%7yD7H$rc2TAQDfjxLoek!SWQX!DUAa=^@nG_8@FpHPa(K{&tUwm4 z=VfoK@ZKD#V1uI7F}opIZ?W3M*GDL~&n63IW|}Vy_`xqLQUmSRn0B;C3Y6sI;D;zx z_2wpt3~Ja>F|KHF-{u)G2dby$&!7GhU;FtDI|n27ADwwy57=!`a9QpA=2M=kTRNmx z>fHL;miwoD&cSg^j1Q|aK=~ebMQYE}-J5uY1_rLo6c{VCvkA-1wF#Y3y&fNrACDiQ z0>cuJUqm$7XPaE|APJ z?{J&?MG)uX3s0oUrYj;k@7OWrYHt4?@TWKJO}~2L+XW;HP^0P8;3!LYPZF> zB-!KRuM{Z!?Y?Apl+wY2@)&w*pbe?11M)UZ9BrOnCWRo>+r0ans<}L#^l#54KH9bX zVzm!s%*U=@^kyB4t06Kiy6;!)v*Kf8jm*9d!RJ@qpLsS-@^E|w`1c!T!Ujvmu|*wI z6w&StvbOTV8}Gm6{PDb;7Dk>L&JJXlR5Z-0B!3|Q5gvUG-hCq$3o~VOINYZD`rR*z zDV}V5Fz>7SlCh5NPYm%wI8LDbz1o)#mb39Bo4@%pj8G7I^7vMP@tx-{J1j>yRy%xt z^LLj6w644PeiSd;PEaavgqAe)us_uL)z!JMyIX9C^@1ak5={WnC&-<qf4my|>~sBrbBxV9 zXS-WggCK*ShS#EO2Xo+(44nE;ilwC4{k01i)>eu!1izB^CiL>sm2@6%@92}1WIoszzG55Ytc=wM}KstXVlu%QPbFUh@96ROQB; z;GgZ5k044vc zU#K%Ydce^{xfOjfqB|3yt#>$=IHhLxzFtc!<##?K-Dh$&q>zN-hN8O&{R(Nm?jP;@ z2OR3UP8&+Ps5jG_*!6d!kcHo#|Hw#E4q8H?Q1I5LBX-3atj~w&5`#R$w z*SPx6VyJcmlA{y8-bH%%&24sws<+Ou<-{>U89m{z5p5f8l{2{&r(Wg6@~!tR#NCiu#lBQ(yOTD; z?SUNE;g&?e({7qB0=r-A9H@1+QFx4IAa|xI#t9`t;Ro*j~US%}v|JJRz0ij0OnOBjaj zel|F`W*`s6-|p)!%?UeZ%y3%r`JzxiOT}h&Kdz@-Zc1UKY&@*&%gzob ztnCly0X3&d89V~Y25k99Oy^UAVjUX#VN@ueXlw*{Fw$?6`xE~?e5BB+>ChDaR4`GX z>$QLhWHVinTt)p{vRp~d<4sj>HgfPTwf8zRH(Kt%MH=>$XD)siU3M~VY;lG9@r%I_ zgOeX$0&dY0VQi;RmGUmKZ$9uUaJSB-&{-J90b2uU(3DoA@3ljr$bQjv}*EeEIU_<(sAy5ealPks5>X6Sgt3hQOC7d+JN03WmH8&_Kh8kgj|0_%_4}P%I?X zTStqpEk{*XQomsJ?l=I}%ydsr&y~xT1$^YL*uysJcP_m9B1h$5QFWqD*f+Fo>*V>l zf{>_B=?%Dxa+$YrT~RzH%lXeOzLAxzX05MV`zzgSxG~>dH&kA8vfaxp6q8AAK?2pJ zun7E$)`rn09N(=+W|k!Vaf;${@$~$NZ~ESLXV)rJvY1dqUE3km=cuv~7XV>n&TG26FBdC$9;DWv176 z!YJNgRmmI8l&sI9QD3k3fMZFKv3g=Y<~vR6IsjED1^ z34Yk2H7~P%oi`3-8uSQ74hx;t)xP8U6v^w4rzQDsrA7RyPNynjP0fh6oX*?Ojo#jM ziTX=CzmMra>vK%m&*hRHdN#~v+4mF41S*2N5PT(x-NPC6@X7Ntxf5o4zcoXV{??s| z-}Bqadx)q@kgmHB`FUd@zKR7+jyRXB~}@0hA`Y_RIX=Szbpns<|)T!4o62 z#!L?0u^pC{aR^tZAPsP+GA+^6?Si9$we`?(b%xs(TpVP4uP(lckxFE{$CG-oszkkS z-~F7Z4WUmiE=fflPw6X{X1sj@a0HOLb}b$~;-mzK{ymO}*z^V|zu=CiqhTn(9e;xp z1<*uOt|BpLA}bB9tPDRBDl9T~Gx@32kE2yNZbmnm>P_4;GFzqp-tS5eoSXYub`9f3 zYC+wq8sALu%XFS%K7_ksFTl!rxf)d~^QCcoiy)H)YGIR2Vt2jl0~7Fbi{~YZK)c=X z7hS@}#+T9iUb;L~Ki4#RG2)DV$AVh+}c&? z`9S4!ma$Io^|eXZg*9@pI)^a+v+=FZgJP0Kf`uj72+WLL~7qr98y-N@-&mCAiD!)YAfapQ- z+Viv%{SMIkC;OrpC2w$eoC*qRX>~{dM&hKv_Jd=pwxMC|lM671ToJmFka1pt1^d|u8l{e9 zn9W=VhvzlFU!EkEWQ>i!&TXryfnvL<9%>~aPT}=D}?=LY%7H2GnwL&Q6MdQzkr7aopCh&5rky%7=Z}AlqL+( zc{`xX8XO#?>B3ac7B`^^rZfk97l*R5v7Blxw-H*P-#;s6y`OK6el{`zkX3a&KjTNg zMJBLn>qG_r{Zd<$;N8}kqlk-dtgt)-E&SNxCWy1GqM+%`Q|6eMxI0%Au_NEF z+mKleL(0wn;uF8dI%oM6p4$2#oJe>3b|q=3n#y9D+xkz9S@65fW}Wb@OhAHkJ>V$) zgcCwVa2-ULM86Y%AoI3^-$bmf?N`;BwR=*p)IXvro!Ako<&wGv-iug*dlvGFuS)kT zE|$Z;KxEB?VrOm{+MG^@RR1E*5A>JPnRN}Glv1;Z+7*!g61kn@G$X0k+ED)pu zYn(6oS&87H!otD&s0NgYPQlJ^(zzL0TDG>y&{e0pD~`P5#snRxc7aUn#`GE!C+0E6a`kF*PqHgf>!Sq$_o=mn)`H6@`2$*J3Jt^2c-o{UfpYQsumve@$sRtc$mY(au6*K zRuxA1o7z(VUD15pY5so2@d|KuqH?(~R;FAEJom1e3no!k%cL}%JbBXEs}Q2gpspzl z4~2v8HbKX*JDpB(zcVS+Y|Ok1$V!pTy$%M3O40^86u37mo)Xg#?my z9@_dKBaW(PXuYGa#a6^zTYkt2gmhnBo7{xG3I3Z?5)4N)M4L+@BZw%xmkp1*Ri!IXeXZg&U>yXPLP=z~?V*&=aE=-rir_ zb1WKT1y{82JT1Z9I$uBl=@(E`4u5Wb_1@Z+cRS!1Wg0<%;7g(q(DgJzV|Y92Ne7Vi zErOn#Xy7ci#5ed2Dsvf=OD%o|?A+Hj?FhUK&4TFUs>hgnaltzUPmc8np zX0&W;+A$Ek-flCSxf7yte#@x9V7V8aBhgVS%vyIZT(DS{lAYMpx`1=qRvDQccDLre zVynm%aA}aXRy!YFo~~pTUEQ41HgTI$8YxA5l}Xx%ucyTe@gI52;2dkVJB(qO!N1i5 z9`7#)QliNRaGwp(k!D0aF+hef^=+6(RtE+F8kEHa7QLWq!xA?ZuNlCcgS%=J9`~T( z$M`rVQ?F}rC#{gu0!H3dvaA8SVky$c0lqqYDdou1CBM(1Ze7$%!_mwwhzUp=71=8a z?r`&=u|q3FPU^W9*|d)@k`oAH*9b6%8r-$}Ymc(5Y-oWx0EkdfxL=}U<`B&O&9~;- zzx4JN#GLx-N|+|A0Oe4*bFL&&HBz3PC|n~t8sLV?LF+q?M&N(vLB!qLIO z+aJ`t#ni}qslNhr4whUq{y&+2pMCWhcWjV;cpTKaa|3`%5^8~1tXKzjLef0X05Dqv zIxZ2@whxk_-52&=OH49tGkEgYEudyP&dse?nmjHhiUe(9GjM~pkxBy8!x6t@i9l9{ z^?fm09Q|w8&A8k(geY<3wlZKVmB+ANF(=g(;678GpQ&M|!h5eK!olll z3Bc9&W{OH58peDWdqB)ME3Va#LvjdRXqET&>@6=lF9&i~)>?J|=O$*B^01rk#2Z=M zL_bYk&(r)1-`WEMC-u!LW(o;icWT+D{7xU8!?-q?LVl<+EN?@%qXyLR>9c3|nEl8^ zp*S^=U}K%wOsIhWK@m?XS1}2p|JdBG6kO?0jp*N;=kR)WfO1?ZufGq~-v}j1LBnOz zzD_?@CA$|I zB%mOl)%^M0_iO_b(w4pw;~F~2#i*#JIiDq26&bxj(;e|>SP@Vb=N~V+lXE~4MBxJj}G^> zG&X541XhS^qceTl$rF_l`p~-BMNC0qCluK)AzZ&2_18$2d+#$3*COceyS8FO(Ky{0 zo|!T-GAb^jXWo@Ugud?R=NAZd=`QDJRUH~0uBN0xh4!BB{n3-xphZcAFy#|8IrmJj zuRZb)bwbeL_+A~%ObXk1^g-#SS)cP3zvXWo;K{pyZA@c??lFHLRPj)2!92)mtMP%I zd_SPpg3=Kqqi&jqa#~(~VNhifS*p^WJVyej()?X&xqg$rY9mcn^79Jh*5y8z|2dv& zbtrE4j9If9SR;qfMW^dsyl)b;vC`g5f2m(9E+RxY>_djD`Y$wB6f)oEyN8iSkz*=t zMX1$-y??54fQ>z5EDj4AgO~W zn@OwW{#ztDE<#H48q?)BA^L>U3tydD_&o)CPihpu?{7+W4y&qNHwH@qYSSopu< zn7Z4i{YPGNTKATVcE~j{iJ#w=VC&`dN7A|pn6Z||hn1W1P4xQJS=&SaQ>gi7Eg42Kw4 z0l04u=2*jaC{WR+qg%M)u%K6ro=BB%LYP>ypCDrvV%y~LJ)tB+?iUSysh+(bF&xfl zdgxZH9;YaGY$?9T>HZSHK4`)al?~NaG%Sf=B+lfGE~uf>@>_CSJm%)Kom_%xz3~LE z+4`X2r9o5yXF8(xd^BA+3vM7Vy$2YUVb&SU47CH&VUNi%>qyfabFa7L& zBBHc-__>wq-7`T!(EZv>UBSpT!fh^4-hzCVS8IDtKY`Ky>?N?TTkwQ(nT~CR`Qw@M z7aM#=N;}Q2%~C<)VDnwF!a((A<0d=N2x|j{zudVa?Q?h_!DmHhzgN>o9B4aPGV$xj zKdp>ucaQs!5MQb%kLc8vP80;6aLamH6l2o~)J$WXIs@baAi-g{)>4O2kMsiQQ-Bi1 z^6lHBlKt67ogb`NyUbN~u~JU|)I9~d@$naDu$Qb1oVDa1G>6P|$|Y0UwWR-msJv%l6DbZw==bNAD7kRS@%yeDr`n^5FMY&XrsyjZ>S8KvcAW0&-c zJPK67gxs40gM+mokc2S}E?XV7H&BBzR^+KVU^t*C=(Td0LI6Mijx^`wbwnLTVNlKu zR#sNSaGX*dR$^R%(HUquZbK?+ad)`>qR zZ;6*LIyO^yO5Z{KA5ZpDWLdNNGjU|1A`PkIg%iW_GQ~T7ym>vx)DQCaBjrmxu!!9f zD#IjQzYi|kxudIi{d(VtJe20Cz{}REG7loga2VgQx4Qp9r_0nhK0B-@sE(YnuOMw1 zOzJAYg{wia7nR0`meS&yv86}zbx64I((K`;oDIKvA(CE*Jl~lOYI9N`@*5Ix6>JUC+OUR5Q|DZrYo+!i(VG&r}V+6@az?we4`)U&0~YP zEX3|Y8+RPtJHGDKOIc0FfWT45q|fF!{ zM(NLy(vg8;fUY?>{3fHBajV0`5d`SviHzm{okIGew)HO|*JEE2?5M*@7+_+ZK!jjEDB&LR+?9SQ`MWGUr9f^_5>F{kALf7J4FdyA#Eptp3(an+XE3JVQFcg;hlYwWv(ECuXO z<`Q=?9jHoQQ7WL@suIgHXKK$c0@r#uRCtWV3_vh^b2ASC(~X7>I6)hfZfr?yeOGp6 zD0bb7v2o_}d4kW6PM@TJ3jnyko>~V^a$S}$d!#9OH_Pd|2rDgL>8nOO?MMi_$0Ve1o?8iGD3<&Sq=+LEQVP~1N2kp1a*(N|k&5;{Ns zAdNp$EVwvC6i&0)s@-=1X}p0hw7KmsgnmH6^A9xrYu(?UpF3~f?T-l>vQHsfUYEEGdQIzX3yfW2@>m3T@Ht2<9it> z1E`evl4{;;dv}JOu*Ta_JT6wy9`3R91|0L0Ne)>lf@blo>NBmjq?_m0I;f#y13m!v zhe0GF6eLo$W-8Qte9vYE;g%6why=)JfU+OaY*inenq ziDCjmZSGeIcV{m9G-$jtN9*89etvFiW6cvHK4{!NwdA^H-0+j?MHn0{ zd|es#ALiZki+n^P+JaZl80KZTR57oEfWN|`B2m*{g_vl)A(Rz)R&~96{|5@U1Z{ee zW%I>Llb2(ZX@l{z>%Wi{$oS*91@t3pr)A#0^(9%qIh!hdl*-JcA*1xc+3> z4X;s$_JK~56|2GD?f^7)IcVDG3$_X^#6K)N&^}IKST|2oYzCx9WfE3n?hxkAr!X=K z2*&)#Y5VSPjfbG0HJj_sN_7j0eL@!-Ra9iNpO-h}M)8$3yXvP2t^Pja>`SFV^ag|= zkm7kL680f|ijypY%gkJw;bMbXe9$h0vYZ`o9f=SN5C3|{l>d$5;$3NfE+`10EouJy z2ivCjUyYW(l;bS%ef-IVq;xZU-04jiWJ!^ufS}(WcS65Fx;WydL%7}IPEW6@JK*)3 zIUY>Yc2c>7bboYGtB^fk4;B60SdkjC4vNW1)Fi{|bhV~9fbs4VlczLGJT?VaD9d{Tfi zmS}AItsnhxzG}4nOPZYZ2Z2+BNa*`R&)2y-+lnLNf$&AZmVvgMy!xzR0}%&JH6MY_ zkcV0ewdGa{BZC4-4AN>U4Coa71~?;s6+ffo<=nZ4il*;3G8b6L9}xTXg7-yopO6v* zR+@W=9dZ^VUod4sfT83}X79L2Qw6Yfkk=!mZVreG`ZE71=Yn&cGUxNz<%daNp0bji zd2IJV%ebWcW$JD9I&7nJg|7GX35!;4sVx!m?WmdSUpO?H>p0f@I(tdjqc_ztD=dHSfeeA$lWzHu@O7;Rq{Ay$A_3^p{9EzM zU_2%yG5mIu_m`px%m7V6BS69x;P~Qqo4vbxah+1T@r`&%_#_+PJDfRp4x>Z=a}j$X zU+achypcui6-ZRE?%#d>!iDhSV!wdj*DgwS|iOh_LZE}Vmx0U=+ZbCRE%hb>s#lqLZWT-!sElCM?c>& z|Dm(>?nItdP+e+7?bh(x$0ZuhRgW5$K$G(l1|TwLvOi?ke|$J%f2sx#4_!oSJ-(!& ze7J>{fm!V9bFC34jxiO1FtFPEj`bc3U40{<5e^1mwOb(DSgpMcqMVLdhe|v@|J)3~ zPuQb;KUkBt5efK+npPK%SKF^XtYASrjw_C4IK`}5@kpG!`h z>|Ck11F6oV=}EJEhQptYuYErJ-uo^cXeXFN zGokboh^ejzlY-%ajf;2d+E{9VF-bJFr@cBE(a!>`)bAKPa3LXwk1pO%!cN+7O@tCi|6St zK%6V4(mK`9$hoj^B{jg^ilgxy2Ha3Ojm6!I<5#+p<8s7YFi!l;={xdEmCyZ-%^^#n zTO9m#)Z}8exn4%O`e4O!LJ%iDJm<80gik3CV>#u8>RsWDeFdKdrZlY-uc-X!|86-@ zCIXJ|+5RD#2#pQ}`Jg$x0cztDKp5SEe>|6&#`4I>R+Qi2YG_P4B%Z$tEfZJ@XG)=!f5U;M81L+>aCbQHkj z+Eq(Bjw8_|<__1YWu>(S9FP91(kt}!HIEAngk__r8P@JN_hHg(JGHVA!U{4gj(gCzFq^dz;sO4JYu6eG<3P%A)2^X7{Dbmt#>3bOB2HoOVixe8<;3_z`l- z*B1spccD+SMiE71f-Se-1I^Jj-Bzgf-kHXh0KU3wyEBHV?Bkbq<=RC)DVw%4+> zEe|p)Gk#pL%m3WhFISy#hpWK^89?p05{=R7Y%Gt795*5)NfjTGnV* z?T>gfy+WI7hA&f88=6w&_eEqbN;mP$NFAJM!aE!^%dojEt@hc$7rHXO!dBk$J}oUw zxmEu2;tfNRr%5-4)M!*acMc-6Kq5ldf^%kN@Wsf-$3`(sq=A&kSza_WG&H6F z^roW^cjy-6T6HI)AV->G{Z#@`6gh~O6rQ)VW(4Q(Ek3@Tb(`WW^OY+E54gtLl)s8D za((moSnU=s=X+8f**19*xf`l8_#ZxumzL3qyFGXATxnb!fpZ|pl{VyDB$DW5zgy9%KW?&c(Hy@z?#5panKO`wv{#Ve`I!!_%W$xYcH-?C0RbJoDY4DQaBjWF-e^l#yi_Ep#72cn)Xb1pTH8^`BmhvJb}ydNw9B z&`N0D8Z#42NzRPZ&Gor8eE}n{+TXQBZ{+o@p2gmYG2Z2G*J|7{%@~;|Dcg>DzvYkl zCaykj+LMz)#4q9qljc$H@esx$5aoiMN9;@NDW#}YK(HeVD`4z8>JnmM}X z+Xth<6M3k_;?cI-=rGpxGUU<1?v|e^JzyvhV+#vG9~no9s;qL#6An&Bqwq$f$aSUM z=gtR8zto?#P;8(t^=D_TG=>NvixPQZPTsg^93`O}CcEnLp3L}r9yv`-sW^)tVOUtQ z*SdXcN@cjsWON^p;wMg)>4W37@^X(s z)R%H>D^njq?9v2rTWX%I#FxKO5C>7-)mvkjlx=B}8b)rudGa(PNIdwueQt1$u}jKX zJJqpgzrJ@U=_T2YV)`_v!2J2QA)Wn#jp=f42g7~0?&SlSVzbIOo0&hZ_&#OLnqx@p zT%TKS8xu~54$TOkGL$PQyhb}uRlPlP;}w;r>6pLF&y+jm;D%2kKsA4M!#-IGm6&{wF95( z9~fAx6;Tx|^R53_Ik1<^^7%?YkhZcy=fHQ?}!gj1vcC49Bs%rN}TJ?r^m2 zDV<#qJ(pR&#hWQ;ps(-Cqcx1+baaSmyf=*s4Ru&=UmrsW8n`jl6uXKxu<^}>&0g{A zab-=N)ToY4Ww%%8#7K&%Q|^a>EA6blDnimBVxf25rXM&9n6oqf)ca{ySvb>O@A~S) zY9ndbey4QpKIE)=>HAB>MhMAEK70aD<*KA947XEAm+ZPG=7j8))abD|cKcz)E~ES5 z#}b%~EsiWnO_Qk3_SLx~(2}_g8DcF`i&UWYoo~di9@x>bU}Mea2;ouTgFLR}MuwUq z4jhZMR~9l#pFGLUQ3{@Gfra5b@^d5!ls>Z8z}TWxRK7N_Fo!c!G!;RVd|E;%7i25? z)L%waRCE}kLsF|_6)3|c;_jThzr0O8I45eqJJeUT^2Uww9a97w$Qp~z7>pkgM88d} zVGT%L2xN66P=L2{Zj4HUN$!zNAnj?HsGK^$@@sfwf}mgm2$(OqvfMN8IVJS|8aZq# zuwGM6(pu4D&>m!|f((@no8I&dCO&Bym|w z!f1lG?B%u5%+Vl91yOSD#;zqpB(iImDgV{`erEpb;peNWMt`}~E>p{Xl{klwFA+#h zCro83F8aO8qmQyn+kG(h#!=gFWJj2ApSDSfqeyR*qNBLkEGcwUm$WihvooN=aWpW zfMV9})YjO>Dz>-zeWZ8eey||XC-Nm$jq`;ftQjKFfBeIx$ zX?!KC@20J{cH^H2sp-Qf#>XejHn!Y%uO3!mVjOZJq5>vOHzju55(>0^qi(14Q@Q#5 z`}n==`wwVz-Ji;KH9n#3FD^lkDQs5xDJJ^+wH@%wIs_dfw-QnVnau!*s2;5C0+c{y zJPEdRC$e;#LR*dKsP`Ld-+WnPb58xnTQdFz=-rWm5tlAbQVZwJ|8i|3W7ntFjFql9 zKI27JN4tHPPEK`*-dV$&_-8CxLTvjpVu$MPCNYf-+n~Nja{mA`4es`Oz$}vHIMEqH zy8-VGFSgHr?Pek~(@=o3;?JZWf7oxxXS>gD3*!(R{X8+tq>F?L=%r-Zdv(1LCl(y6 z5x_*aLS0(2z(T*Wswi;jGL6h#ajxR&$C9Kx^P6TKATK!Zhshg;obJ9LL;8H+qp+u4 zwRPh8`R}(M7Bryt0Tdp$h~)q<#3l$uY!a9qAeZRgP&w16wZ#6Q#Jk-3y>4!~IM_ve zAI4yQkrvMAXZOZ%0P5x*F^`Ll#kq{^K^y;5OF8Lei#Fy=p05@HcTyOX9%sY|} z-@G`Fx$gn#Qg3jCcx-Ie(q(bWHSCR9CzDKxmhjvYzcNUSPRvUbD(T_rHT+m*RIm`6KGFp$1S#`V z&fQ4sgns=DkBVI=tKIpwIzHW}`v@>#@T85`A8M57OIl^QXG*Y>eM_M!N!ehad)TQ3 z-7R_~onJoQ3Q;}#eBaB8F*);;!Jc&vE*QK!DMCh!BRji<5k|d0o$%XvXSt^Bv)mvk z04K2B=sRAyeED+kH{!tIEI9J2Pq6Irt)UAJTvGP$?x~U4pHTHZMY!c@BP*4(F9Lal zs0E+-_@`7 zzZvUkYKTu~I@>6HC4cQ|&4QpsdYkQ&Emt|5%d^U|9lm3u5oaN zxj_ucub@y{45y9aHj)i-LE6px&p!G1U0r{;6Rern*AEfZ0DXW6^AW2k_pPKpk*(AM zc^NiZO`ZMoM71}g9=U`x9tmx2#=)J&&(8$Rwq|_K#;PT{9#3^#QxCics?ifPF`37h z;Ub?N-ufvnp4E3e&HUX#JK2q@zKzVdm(V^ynM$l*J5@wfupTYSlGn*LshFibJEqaIzdddeA+9mYi96sg?URuQY(+ zos9ZmY{b&?!$*x>=eKR$sL0d09NCf%KBxA9hbs*^&-4ndOA>K-yL8Kzh|mkuXRLcU zZ8nePyC8o_fgH!r+}HqEwUZ15c#uPVvZ9EidBO2#PbGYXFuc*`FMh#->#b&2 z&A8Md`pG2(X@zn)lXB2U@VQ|~{{@gMQNwlbyM0q{I9pbT->mfy(3viBnh(6;L^|z! zSDOUCPfAr^x8dM&!D6X(Eat3&bc7KB5=6)AgBN2Wtp#*G`y836d%36&bOHf zvbVJ|EYvijEYVCfvtRS?e3R%z^uwZiT_-Vqljqy~aR6_PP~ z@p-GCa&Rg)*J6;AC#Xyvi^wnykzNnVAG+PDTv(H+PYJ(3mkh;=yWe|#yPAs@V{HK) z=lu6a8Z%PNU;G#_oX#oTw0WxIEUZmTkhKOBOFdq9FS7~5lR&>|01P!M_V2&xu4K3G z@yB{uovVFs?tZte6kITa#k-pq(DJ7jVO=mSe1i>xFlKS|L}ctHuJcM7RkP$quzJQO zoooSK&Rd~X{JnL3%l5vaH3D+W(Xqfdi(lWX&dt`Yh~m=aXj6a#Qxym~$yfQrrq*Gc z2nh=@6^_=X?~AZ&!Rkd%&}Y-SIN@=p?N#>-blbq?3kNnDkNq7v)bh&-qd{aeq?_S| z1P%RjpcqJEjWC`5Zrr1iX;KXLY7~BVn$mBn-ZT1{8#h!g0rTt!I3cvS#D}-4Hm|o+^uTmHXAVd1!&qGcO_ZPrY z>D2l4>sKOz1HYR4s(JnTK{f|4^p1^|Z4+4-mfORVC&uM*Zs!+9j- z3*o7*@a@Um)yXRkA2E*E6taK+ej=iFA?x8Q{KX%*6%6;SM9fF8@b01!wCAXk=&)%0 z#*IcZ6)x9an3B7|hgI;f8o2r>?}^IW`wb;Ol`vX2R92^OC_++geMIIwsMG+Y~WZCsfI*{q?5X2N`dTLV(5c@OV0jPFhtEhjTx zYA=SU`F@>$K_z9q7#Q2gF(ul8=w-UUyyy^MR?5};hx5h z`^Oo@)tk5NJf>4B<4{~BuN;(#vpT10_j!tk1t_k0$_q{*!?uF=Rse?NPYghyuh`)#8 zvf}Gcs`#&$Yk!)Z+c1TZ_6&#@Bpnxf*W%cxh62FDBS-aMc)Hr9U39g_S8m=$@#Rl% z^fsTk9hMiR&~tL>cz$f(_|VXkC!1k4XM|X00LfhSbJb?2B&%Jetb(W61lQa)04h>H ztmPXWo#+YbpE0ku{YSvv@Z{CUA-*@i6nzewuSfk0+z@GI*tRA))TeF2phGjiQc{Kj ztk1>rLMJ)nqiBk8h<^5=>k0#mH}Gjr_OefQ>MVO1uaTJ-u)C_&c@V<|b;ucVE3{}h z%{H3wf9Jue+-_AK+!P=*`w>fU*uBGRwrmb>9+8~OZ);mu_`t4{IoN@`hcGDaS!toD%#xqW+Ow)2|^YG+xVI)Ug$rY%(a$oz;)6O}hed0u@#$mP2h7w7kf#=} zQ=rtMd8tt-quByf&DMGjJA5fHfOmfq39MBw0UIUn=wKAb(G=Cg>mrrRTe@m5wn(Okw znc(Q6pt=l2nSt)P`%5LY`8VqBXy4>3rwRD>F2+~}EL+UR$!}4|F~uD#zpC|NM1}wC zSup{9g-KSBN}wBJUz-M6M=sGd^locCR6DbDJ&99j+6(Z99U<@3jKo%{a=ONAw|Bt) zB$#b};8ulSZI_HPEdFwDLCXb0-h@sbc4f|)!jELf+K%@u9|tQ>34MKAphIdggrjsFyu5#zyzqOg@OFmdCjHQ$bySj0j_uV?Njr!D0E)+wb@%jN}-$MHuyNOT#zMD+*SoW`|< zAOQ^Hb0^J1Q#fQx0Mf$fGoFm7J>>Tmp74)SFqY1CII!{^WD^Zw16-0sr>{qBi9U8G4LFX;CRe2m7Tlt z_qokrSUiI280~f)oGeueCy}=OP1i>HlDAd&vZ*=iGj7YYejbyEd2(11UB;88vr^Y)h&&m@2pFWJ~)DKjyhHiDnG)_Ca(8L zZ8SnqVV`lywoYbD);icm$#E(oDu|_)8co|Q zJab0PIA`M3zU$$qfhwwTqB`N8%g(;&wmL5aXp1Z=$-vQM4?ddF`g80+0W&AD$T2-S z35R2XK;^z*C}fFa3jjV5;QaT&Y@01x+xB7YUc(XNgqGeL(At5$!Hf|9od#56Az(dO z?NnFSMMDNc&rs(Jpt>1>N}LayJQEW>$9wOx;)*7+i@fd{RlU0YDv9lFFUj$s?E$+x z%BH|2glA_)=lUGEo&FLtwgu5Z7dz;N_!iA%XNUgSc%8{O7*&iiO=LRRcF+F8)ro>L z2W@FJhRNRmT4}s+m%2K^f<&sjB5tft@Yf;Rg2Ch5P;-UT zoK?;LLRkK>OG}qs*A+JT1jMKkF+)<`3_X;)W)G;_!(cdy;TF4+28-O^$xs+Tt{SMF zq(l~~&UXNwiI7{pZLw!8@Lb}W;vQ<-+b8SzvoSW*!CW8-O%3tKAOFS$elPc4Z5%w* z3Vi$#3@!uY=LbtI{L2U?H}FIfe86`Kn_L`EZZnm`XyZ{8XtPKra^-?Y9IkL51QR?- zKDU_UXy7|>cv=1&86hJK^2s+fLF8q$%5zQSFZXqGPeg`7jeNkJqGYgs2eT2kEWkz} z$bHTIucyd$kmef4r%0=^2ncVMFQHw#LeSdv=_TCzV2W# z(s80CVHfX+Zq9vQzi(_rE@4IP8Sv4_{g|95CbQ-Ciqu(ZHwL+Kk0o&n^gLm|Xi5gy zc%-W6Aa*Po0wRrY#m#R!NqSPP=ioQJL1t2yL`o*LPre5#0UnapR}G$HvXXbZJT1xJGz zRA}%EjGd9BqM5e8g#E$SM>7D5Uv_WddF#$1C#Cx?qr@=oAblx=aLIyM)(pp})2FA9=g&pH zN}G=_Zq;#>ltmE^`Q^=K`vF`k&<~XOjQndV0o=yyq-UhY#tzXAO|19Q|BFI zVhBAL{r-Z_4-`0g`D?VLlx0XY05MMr^Hla&4|zpJGo&+VZgUp9)BFWpFo2vNbA)gU zCti&;e#7;pT}0fhoU@~GWv0Zbd6Jy#w#TP!hQqV}Jg)0(*+4UoBjL{ASjT||8Xo?! z-IV$(4?3yEygx(+^e7K7k!Lq?HnALZ0F%7jsl{Mq7&_mxVSkOxB@gsar)zXd4vnt+SPcC_eZNYQ27CxEmJg& zQ5G~f>K^l+3o8Qcz+WRH#2+y|$WU&c&1WCcmO*ESD9>Dy!H_Mk;!c%0}sZy|dT--Q3VoA;nE|-_?m@9Ao*u*JCUQAR}jc9GK5LxH2 z9zA*Jp zVR32RD)n6zPfD%c{s@h258!^y1^^1k#M`|K@Z_jV2|c{JmEC;A9!v^;{_>7VF9iZ> zMTduni#70bu+q|o1@twLHp0hBmROw&l9~F}RCwhM_UT8Peti!{RdWY4fMKxHB^}lu z>(u4slYFv;(k4bWkq36Ua9?=`o>Lb5y@`rWKX@7L!!@$($Vw?QfJjsa@+gztJd8HZ zix>6Jf*ZQGs&T>kHqY;|n_-a1C>G{m^`#a#@B|wi{2kd5Ah?4?Jn#_eXbA!omz9)6 z#D~q~3T5SJjo;4&61Fs%5P{5iJhDQ)N+-)!4`;wxHkDxg?dNLJZrpRYYWHfr6<43a z+kMc!1Ngm!mQbkq0>lU$+DWiMTb+!vnsMZ={q-A5AYY=xpPDbQB-t_S%Ht=Oa98Wb zDWbtby72|uvLZ#hb!mAe!!4##Yecb(ol{z48>Xr1StlDV?wKI|Ci zTzTJ)H?wrZYx*rF7FOyT@nwI*ZxP}OTb*}jsG?+KQ`Q=mIU^s$ds>pnpvf7C06XVT z&*!O0o}G^XLrqSa!%9>^ibIb$fP>t;+3mH`s!P9GH;!&W1cF5;-grmm31vC8+0U1j z3r3{8kCa*~F3Wm>7ur@djmW7*{|p~)#HvUN5`tx158>jRUW)%uOiT>(~~Rz`;>(8 z%3v%TfOED;FUVR1fQV4s^}zS&_mL3>Ddj~aBr0E5KVn&{%F=57H^et_&jv{pzJ@-s z`#>s$n+iRRj~!%R_p?FLn=sUe>YOP&)Na52$x#qVbS2cHQlKp)g@#RoA`SU*0@-Ai zmI^1GU7B<5{ACO$ICEWc&a8dIC$p+8)dDAmhKMzQgy9MqUV*UJD7z>MVV6TckEkgZ5W_@Kf%)#H0q%8xBw zb~pd%)gRwVBL_3@(PWYp)5(0Yff-wqb^$a2C8fXrrU=(1uxrU82D(r_Y|nRIJAR zd*R8I9oNsq<-=O6VOtkEKHe}so@EOi#Ku&Zz%lCE>i(Kr>-c2a2-`XTjBq~2+kGYM ziN@>Uxc(yk8>??Vf1r^~NgA*QvK6aQ%xP&mGqMFZVAs1Qh0Rq#1=$gL%jd0P-eoMr zd5QbVGYKMS6Nev%;)Vhhe1f2{EWdS{UDPAkcRbvWt&N6XJd&O};AE`aee<+}>M}O+ zD?ujlrB{++fhJV?xY*1oNT2k@F9zL;M|Z0P060|#40)#GPvUoWcB z`V7S+DMQF3f{(+`ekF$CGQOH{t+^kLt$|qyW^_a0EcS9_&ECT9FO@dj;zl(c2OgdL zAB@M=MOHgPb#1n>PUCXX7RFno?NmSSF|y1_^{kPAW$xp>RorTURkCj&Eh77`J4RV| z*4<%AUVrQk3Vw~2ikt`cfA|YEWhHMuXVEf8HpC|H$(JvUb01}_{o1xBZn`|JX_!1} zf&G!0xE=3b-2XPK?KJXIcRyAGVP6n@uv1MOSJzj(7FA_zr~v*|o8aOw=GYN3<}0yf zEz&lR^wZ(({{D{E$43hiI#N-QQ@}!-t$&J4W2xUKoi<8Ml0RnI(a=F6bAZ?#YZJmM ztNl1;Q`J42p!2P==(0x*+`Je|NCA#snpJ*V<7Xj25s3^H^y64xO;Tij)voH^c=pY`Z3q^cin$)^vTZ@(=1r~Aj0C4 z7IH{6noG>j7?{D>cNNWU(DThM%Rh*Y*}fhpgRV;kU2Z6o~#rU6)Tsj-nl2-MsDSEXZhN0A(Wd`uG<>iX{-MQ zJt|!6$YP3A3^Z38W07RKPQHFU@y57duxMcGHaYzZ4;FIB2a4@hp~b3=2ZN&f^MPFn z)T+Q3ftk`k4{562eF0>Q>UKwmjn@@V#B&|97&gJrZg}R+1pS?htI~I`36ZG2my1N} zQssVJ-hM?pE_S5X$wyRZ9~vIqKQWX5_yQ@*(xpp5VbnTv=1d~acbaSg zNap+Dvy)uXA6BaM`L#dB4P(5qDr$1mI~1g^g3Seh^@_Be?(>VA7ILW5X_xnxsgEDH z^BeOZRbOY{n7bQ0V`rvUTzkN7WjXB^X=#a82i64N{`cOFDb2Xkf&ff`R9(L~lk zMy(aSzeIOHY2xA%MaBM2hnp`Wg#D2AJf1z;Y$wG(58n4=TZepj_*ac6dI;(1hB0GCWi$$b!K%=3x#mK^y1NMr7Iue-aJ2epdn!E{8Sbpav3cckEHFhS!;IM8z@X4q zQPLV-d~**B2MbA5{_w0RQfk?T_lmOa)J=qgR?<}$*F0gH@K`k4Zo|rgno)!zz9>C= zfvKBXiG<}4Cj5H~9q?fdW!ZG7tumr5>SOTq7xLY7vX<<{ZPSV;Ar?eaNwgEZX7s<=URK~%(gCLl{s-l zR7oj8-kdShvYqWMkqe7`STYMRY=S{C9-24x1gBjB_8ND$UtCK1RjOohfh)<(fG!Yc zAN=%V8=m%Fy>sJ6Rj7E-Wj42zvh7!`uBbhW-s=?QsUL0sE*5!?#XFhJd_|>i#ja2A zf@prM|FZ_L-z_x4!`b;Bx}cM;QK$s;Id`^B#|8Z4^p^>kaYUY|^PLZ)oG#B;-Y3<$Xuw8Ap zqFwWXUO`%|-X<#y*!YRcK-?1IT!2;;;_z!KjHgHl0Q&#KF1V(M+Vl1 z6nFrh`3J@lG@Q&7j;#6pU2Y*QPXb~OC5KL^1GUeEa?647wZMz5akACzcV3KP z@l4|!h(*7Q-m{53-gXZ5BDb)2>rV`WlS(akB1uyfd-7KBtWz_TT~Kw~#ypJ5TSR?5 zY~kDBn0BI;`n>qjnYURKCFBbD-ecf_bi(swrxGH?Q?C}>R0LGn%7RwUgX_J6-oU=nC@bs z)J}}GOeEsD;3{tIr{$91V(*oicM=}ZX=VMQ~H4Ys=?WPA&A zL>?YTQBAX6R-wHzSjQ-qW#u?x&-z$*f5rwg5O6V{u=GO`K&sCb;&-=B#*nmt$2&C% zkt5s}IO|38s{n&3v$6$l6L|p7t`@D$oA@5F3oLG%pv8^mG-?rKq%SUNzh@SceZM(K z^TvFhsMe6;mDu-22dE*pZqvSd61p+m{^;0nDDY~olxgba)5ZmZUeK7oWL5e z0nk(?+CF)DuKZm)O}acFR7&ksZ4}s^`?#UO7(EaJ>=@w)%Y$y@V|TduzOyd}^(*ic z?}BwU%c5-4G^q`*V>WRq98F8#$|-%`Uwgc%AhS2~HB(MsOJd@^Z6%`ftszcL!qNDG*rPmZb7%17g70Ymgc=?fS=VAr;7S7<{ z(8XPmMvg;MQ4`yzwr+lP+-n-Av^X1m55b09@yax)gaGlrk}5OZwX#vcq;rfKO9*T< zIFMw4V8r7xcsBV_&Vkl=cGSsXn^PRJvwT=Z{DVR}-((ed>{2_7TlH@JA&bVciz0EY z+B@M~XDXte=H-2R1+y4FOQHa~PjU3CD$&ip$u!Oq1FMUq=bSe6T5 zG*d*;$1}$!#4q-p0f>?cU?g^eo!*<*z9=DjuCmM#XI5V07T5=46_+^p_+ck^fd$WF zej1x15j_WrjwySKQoek#z77*)Y=wm;Zg4B1h=xs4ezT7x=rq_qF(GRI%F>1Bm3=S0 z{l(O5rnV_$^sbG4#Up^U8|xTVy{(ZbLEy4NDL9W!dQJ zW;ai`*q=%(%4L@+Jc2SI{vFFtjVA6@j?Gas&p zp3J^>HertZ8^oqqD1k*WgceQqvga|+1x9nG;?$W(^V%qUf(rC3!{J=)ifx*fFT2fy zR_BHOHTJ8&E9`=zHU_MM^ZnjlmW{z15ES~k{GyCQ2-l*^hnmZC#WVHj>Q{e4g$)v5 z3IeEF2uR6UE%@RHA$)YF5FNN z@#^}qFINmMU%O`i?btx4UQbhj0dZBgrtG=VT7GEz#$v>T$Dd!mm6T!3JSx&U3%K0V z9X>wLFCb5Sv3BzMKZh!-A|1n`-iW3&4PC=z5YJFgs&lCV{cI>etUtH}!x&dDW8lZv zS#YIepE)z9J`54op+oGVa?Ha``sz2_?r!A_+~}?y4RB+^J=tBGeKmN0UbjKg@DB*s z>6DxjD;n}ha)GyqCcf1^93|TpC8h&50j(FL{vXat7pEGg^ z?l768Y>bA2EOF{X+X6Bh3H}YCMhUDSyUj(D`hYrT>4zB%lE8$_oOV{P*9Sa|G6~k zLA+$oneNp5`Sa%rc!i-U3sMY~-IGc=C{`UdCO(XzPoouRz;WU8m&;3zX!X3SYVm4l zDbg3WY1f2C^(utR9-2g6o)qG{z&p^sU(| za^;jd=wX>wS1q5MqkfWe^7h%Bdvi1m=FXAq9t3>Y0pMGNszXLje)|;zAvR`Cr)29) z)hd0p8!pkpC@Lnq_VfdcHVK!h{0z6-pq+N<7Zg;qWbG_LyOJ0v{kD&a0NCD8jdKn? zD7wbx#YCZ>n*WYt_i-yG?GKko;td2FFc=auTs=&$UJ;i(Gp|=-J_p$@BNIE}=}9Bf zp<>p64MBD7iC>q$w@f@=b*VB{Z?aPjmLR=?SwNR}yu`!;*AM0^)rB* zpguy^wLK<_awf|v?#0nInG$NVL-N&(eieBld#VO9`Kjy0D8Z0lXJKr!Mx=$ir^otR z(a|a=$Mn7pbfGO`41ud*g`$2!kY3&E5TV0|6L-veR=SOyLuzW_$k6(!5|h`V9Mtxy zmzlBQ^>vZB?ju8&w8`QPPn5QJ!j;g3EnAHymLv;#sRanvUYVqYf?E*^uK*W)YIxPh zW7EvxI(hO<)=>W?^KbiqNgql^tLFvOGWl^e?{dPHE>+JIvsf-wBXs~cGTP!*pI-v? zIZfA&1L1vl)Q$JA*k;mnH<jT6zU@QO0wx?a6g5 z->khjQb*}S_PRd|Uwc5zOvJbdDcr|iFJ^h4E7ckC@}p^%gPn2FnbYP&tgso)`ZqAP zzlDa)#>}e5!><+&4N@R6St9i0-V+3Ev0sxP!nj7v5}~VyvgK|qW~^$82$f#B<8O9H ztt7EKxaSF{!kM30>*!&x-|vTi3ZBidGavj7 zBRTp92a84flZP}0{H%F^p+qDLU+3U~Mk=Wk$XAcDe5Ab_GT)iNROy(zoTRdSa^{Z7 zy*~M_j@*Dwz~4XS$X8YdxpxAbE{vKK1qB5cByBpxgMm8GLM9@&CJ2leL^dNJ*4&1= zlo%kC$)WF8aJ%Z-N75hMeSB80^x`IFmg{=I13!I6@U0E^+oog~fXu_q&22GY0EuU# zsib2rXtU&1Kn}?n_6tDE$C^vRJHrQt?}gUr1yrOoAqf?kUDsXXAWoiz-IpULubTeh zea%mq#ajyB4!bsC@(yB?LwttTDIJDjiqrz-n^5@ra=rG;$aq86(J>9LH_0~dqIaT? zwrgU@Ya#(Zuxj;c%}fD-G%qi!%g8VOezk3w!q2d{jobif#%uIG7ylX_wtRaMJR6Xi z<9V{}L=Ip&Tv8ZR(6BNqDZM)0_@LpQl7v>|`iiL&>~*=|hf?S#85VLRiN2O4Hc1bB z{rq+;S)zIS-@8-h4w8SFE*`ryEZwMIjv=*%*^94)-xh(1j^Bdyl85K>iYSaE|A?O0 zkf=TM7JPFU84N^EjBd+0+@k4p;YF1<+>mR%9MrhmdHRHQ@9jR>h+%c#SJx2M) z@0aXsA6ABbKiChjAxHoNpbG{<=$Z1F{xp&CJrg@#<(_)`-EwZy%L&{O4-Cg(iE%1=B|D%EQ-^ zh*rZB&FBOS1*hwKt9xaDjA~F5$G`RZ-lj&*^PKaR6rg`?jW26knHqg(xk!VO*2_p7 z({ia2B1B>(+YGeNFtg_29Ywqi*)IM-&Kw`{?B9D_He=xfukK3%TOL9bxD1PW6(trR zQaN?LtVT)J1rCjVjuN_|)vp4tJw$s0gqqN!U-uC`VuzyR=4Q?07h(j48vFmXww8C6 z;8eDqEUep?Ea7u0z_OfV>;NM&y6={LsHMHE(Bo;h&nuoS=a$x%1@`k1<{ne-9QC&&Hiv^EVt zSRxO%6dqN*yV!lR=kSl+z@)h6TMsewEWdaW4L(f1wt->&N{#5%XZ&{P#D|BuZO2#= zAQm(qr-R6bBq7>(5E&8KRo%vU9#s494)PWjk$;JHyBM{{P%^)W;Gx?FjyH`I+CPC* z;x;U6HpDIR2rb?|bEjq-laCMA%gQ6B+BYV~9*}el*&cfH$tceg@ld}H3}l^5o3{#7 ziP)b%#jf&?jov%Zw%zks2WA}_#ex;}&SV5^qa2@OD?sl9@k0FGw_4Q&2Dz{Ns9{ zCp+)zWTZ1m7@+n!b-mZaE}gu032d_|9$^8dVdsv$tA;kyeJfH{7*8IddZ8(SCHkPcgNxP)kqO@SR1@VU_nvg9B zS_j*4>Mu11EBfzO@zfKIri^RLR;(!7-w=9mDI=ky$#|oi*6}`tq=NadgFOru)eaOD zh2z6^*E0{~os&D&(`)m#rJ`aN<(`BJkO%UV-`UCJyRH|k4BiRWnz4OL{;?MtR|G3O zhDJ$t`>%|EEIcCt}tXh z-X7icmq?Trh7|eU`u8+GGR4Qwxxedc{5a1CeTB%A@xFn{8dI zuB=%TIDg4NcSQVEbVkWG4M*vY5TI++BLS=ODh-mk^xkIOU%U1Q-?r448mGhi&z)f~ z>XzYqjH1HhX+RW+zPggBw<^;r|KU_SoN;%6Ibe8Qp&4cyAPIv^!jQ;Ga)yJ*e7Zq!PT#LZ%{422!}z0nATI|ivy*_)j2>E@)2 ziF|2k887_zx34{a(KNOAD4~5|0+lx)RVE?Ff>q3opvBqNR~8oDxDh}8?=Q$R`>@XZ z4nJdR@yiTEpp8kC`Set{FOuQ@x}7YJL5VuTN=gmG7(=BKZ?OwAqyKqztHeC?MQ42* zQLQp76q68KIuUI6vIC(e$9JVMy3eeoB8S2twW6rICC}Rm4Z{B=uK4Hu7>uhwa|;-I zKq3pJZG~PDb(~54gyAVjPmt{&rf3Q0GlTqfvS=>rg5;r(bf{5Fwsq5FS{_S0e&cnA zc=>H3BYY;Q8o%Ga^(YR-G!)#FvJixj;Q-PDVG1~T@?#_g*&zFPm$3!V6+n*t`(ufP zpvBG=Iy@AnqS9zejq2YoZ;n~kUj@kqi2^zn3C%$=%wDr6Ee2&}9C&d_xb)SxXO;P= zs7%(dfBzyuV>7D~bwq&Hsf9QbTmim0sSd$PCr}45|Mrphj|i!vhClkoL%pX6_a9g<8mDl?k7!M{u zGk8Yk%$d`u^Y5_@PTG=6Mgff(gh`;Y>+i~D^6k7$&MC8W^8m~tljYyq5{HIHU2wVo zc?sr7K+JHfAV9hID7dHK^vb*(M-6yKJwoyjluiG6wQ^A_{CUvL|NIU9pM~I+{PAbE zg(R@~&#U+&2$Fxi7M)f8;|4LlQo{M~%exd`Zqk3xN7LqL zqi6LG^3)o&|Bp-0WA|aL?}6RVJD4FBy!hk4v_aCjFXwmmSM!_Q;?VFpp7^Q%yz1^6uJj8ak@F<)5Fzzg>@j!)4&Y{cnN~tYg}L&rSO8SsJCKO;ZKi z@vIEsrBPA{J}+YVzjv}sZ<JC-lf=h7_~?P&nNdK<_yWK*Q37n z->))ps`0<{E)Dj$w(-~wU}qYc6KM4Q?X>aFj{#Zs1$Fm9#;q0q{uP6IYkAcGP!>_SO4D7JcRXnaTG~p3G*8fZph9{T>9@% zC?7JHfa2Jd*QfC#j^>px{)ij{WmXp>sT#HZ2%E(MRIpqT*z#xi+i>dtD82<W-(*d$Bq)hYkh2n_G;haqzptwgO)tTj5T&BHf^tlnFg4DcWcoLJac1kPCX$6^&6 zkx=zz!&EbUdQVg{#@%bo?&lIQQ{@bM2bwfwX#u{5PzTZwqT7%i0(M2gE&D&O(~pl| zz7mE-Vvjf={)oif4pPSgM4`3|R8m#wpmX!{+a4lNp6pbRoAjX+e|`_NBNzHrnpFm=QNIh!n`@xq z=V%xi86nEx(ryW>R|~;>-eBDI=Qo#|jZA@<1K_KQ4HB|sI7m~EH@b9NH*2Dwjs9&{ z_xFE4hjE0DnRAf^&`@HVyURgRf+8*J4zhbs@ocZ3@7WUG{1Ga=SJ4L`3Cga=h~J1> z&#O{4OHsY`590efLse#V<DG*DgCu|G11?exxcH zu6-1Bu2H;0eZKrp@`9o|y|bv>y2%Z|6&k z@)_`S@ods%qj~yHYAgI~#IgbYf3`N1f%Unj>jY#CCMLux`TJFTT{3^ywb!1Xkjl87 z%gx;o;DB!0)za-vA~G^>ZbS+Z0snU~=Gyb_O7A!zE;$q8IRE_;Y?t#IzpuB72PxaE zL>5j+C1fsK+*lcWT;1aYIxYl9JpTC4PvhVFW~@P0^aFjMupfVX(c-zdb+gcy<7vR- z%y2(ndOHfX4d|uyhrEw)!4QF3bF?a7ocD?EJTPu@~xu#hbm>l@6&7yO~NpwWGhk=Qi+wk@yN?W zvABZ4;WV;8+>~G2SqQVIO30no2@sq4@0a(rQ)rmsKn^S!1hSjly8r|9Kp5(GfgVg3 zhA#hWr@>g4F`9(NC)iE!^UV>8u(T#$bX}C$Vk3UgWZSzUF_zomoCmf(L0RnV?2fLY zWlMfWsVz?3`P9v!s;3y8etgTfIA2FU zl6FO|$Z9f2_@22`6{r?b@g16bq1Z$d@2X8SkQBIg8Iky22>S7D)HEeuzq?tF6u?Py zNWWHwa0;xDbG`l)hC54N5u2bg z^bQhW_ZGs1fMXZL>i_c$@b8QO1QKN<(&OPO?;?7sQMFD~22!oTvSc@q01EMF^EW-% zza6*_@xjS1-!$%z^sAK{k&8?l2#A7a!5Ssi=dt#R=sGOS>K+|Zq@veIGc=N({~6L7 z(%Md+rMWQJxA)w>?Wcjqk6j3XBtLlSEg}tAolFG6zhBLddPRc)&GD$!5vVRxS}b3Ba&ic!I(-^RMVC2N7wxgr!4Z>m=R z;9rnef&E7rOTmcJNOvYG4p*~HXvLBt1>yD<78ZVslbhe4SAGmsp$5iL*Ok1Q?+k+N zSpy?8H%S)dl+f!wl8WV1y}d}6*@8idrk>EIrjqc;;#r8y&?o-+%4Y4ILwi$vngaOv z88buwHn>7a%dX#h-|Z-9UE6T3RUs|9hvA@2&z1vj)C8bdiN`^1=&qMh#Cyw&K@?v! z`aNLht1R=!lVl6@US#^4gj=*(&J3$A>y_EvCJZben{(}#oYT{Qqd0)qtiLtBo zxiTL^@Gi0Zpr<+Bon8tVT%1%X4Y@`4&;Ue1slJ9HuOejF@t~tL-AVAuV`cTeXYy^_ zBL^hB`cA{zz7@C*jUMyAlv!GD{Exhr48)`ykQk=m2%-UkpZ}BBdV=$`I+2&*cncdz z6SSjy`JT$k$};*a4B4}=a-u#LdWS@rqH`P8N^yj7VVujc=dxQdv5pS=oX3wI(Sn8x zl;J%(*l{Mtqn!%eQS&lwF&7uPg?*vDenC?R-!ey$ZA-DVudtsl$0jlZ&YjoTbkw6Q@rDMJqC=4(uY7D0!)Zj4~fM z1~2vUnvhz2XGeU;(LOGz`U1ZZI0Rs{vNUYRcZT37OQ3*`?-eoFg`<;%%l$4$#mPtK z-HDToubYXjOpKKz=7WQU6FWk?*w&-PhCbzyG)G2R9-@S8oyJ`prJZQMtUsIs)e-Jr z`MsHS#f-0O4Dc%^ECmY!gqaqRYL1*gN(#{%Soh*2jV#9Md)WY)G%4M$o09e@_{P#L z{;>-zkHmwC_GWZbiV&GcyqM`2cdxF7lw2oH+^_CpVYs>h(m#fsLyb_V(kHu&aNLh@F_>J>RHT+K4i@ICg$_^0PXdvh22uoko2HO$$GM12T% zgGigjDLzcaM+fguJQ@Sww#XXg7EeRAx@$AqrN4gugjF-B<#>*=Nd(6g-z8sJ8q0pa z2V+LjPBLs#8ps+z{JN$`=-$371xiH^KE9HC)Ik@2?eUwTy>6_`oZf7RHen?$aO|q} zgb0YJW`^AjV2Rd<@vBk9az+V9@_Ra!;DM8fuu6Z#567YE>BL%lB_>w^$4<9!c(^9G z-@-Dvrg0$lkXLIl)7dU&@B3u6Z~OY@8KBO~V2p)fNGpGX4uFDh!3ODl?;Iw<3biq* zGk5ErqbAF#FNB{TR{00iV!^!M%vUq&SK}aY`dpq~Uq@Qukt3WOjG)Z+vGoeuf)?%u z_CZG|q6X;CyD1mKxBT&Peajc<<_w^<|M7fP>WbB?Um1RCw*kmH(+LoEKo3-F^-`YU zWWn`l{|N4XQ0P>KJBj*9W=seK$b6u`RTE1RyTA?;bx8B03%xpKj=pJ%V^)s3IDA}o zAnUL`JdoSk+pW?sbRA@*&0PGM*}G>e?3BrpdGhq>M%}p#!2__fz(T%)g(OV4nIl86?&EPj zh9l49p-0ZJ(Vl}5C79DUR7BnV__178Rz_+4$hgOPB(ne+)NzVb<0;LQokRCBaB#F;RcQC*Rr;D2IxecVlWzDD!CP83O$sF z6k|xIW@ZKoaYqRHj9D-tz{Y#p*laCji#tSedbGY8_sBBZPQJ=FEA;R;O$lQvmQhqx zB&rIHL&Lo$0Tny=yig1TEmlf7cWxSj^)5WS^+S36=Dlb)SE+k)G29lT>%W9UzxSEzwQ70biq?E$u|Wr*C*?t_!`!kXMI0NXZ~7E&D~wjz!lTU}jX+Wjh$7+?+FX*L`|kYGhYKoB)C zW^^K0KoAgP1O*gCr8gZ1QKVP^K@hNjf)oucg1YBkTQW0$&cE~HoP8z6E7yka{l4#g zS9#X6o)wUANxx70V%Dm^3>+ARQ2v;)W3y8mMWmNol-cA> zZel!Lg5SP-@i80;BD}mcq33t&1OQ#@i*k@=d~bFAb!JKeK8G3V{JK4R_Grc@P3*d> z?n#|f6~9Jr1qXkt>M19|F&AANo?&2H*FXJf9WmN>w@>a~X)8y-`qsfV8zb0P%h#7) zvinTjQv^YRS}B=9TympGVCwe|_Rv@C+PdYh-4)SC+8?-5-4uYX@GX8axW-LT(J7O6 zrB>p@=}k)Gmh8$cQGXW|B*yu=`rIOrvC~T7b-KKIJnuj~r1YeS!@)meuy&h%vof7n zII838xpT*8XxvO)NqXa_X?@o^tc&9A)x8>uL=zbs2JF)0ikw5{M{3r_UK`#rz*^kp ztWk;f-F!=#%O{oa3yI~;O-*8{T8Mq8>F5$@_{P?GDqa4`*1ebGyOr=hDdPD1OGEJ8 z@apM5Sau7<539nd(*K-75SORfQ{j7%#`$Y&f<84<+*lP6vxS>>GS3hh&c_BRkQK$E znmK)_IGxFHaZVv&kp7BgDD}JBz}#tJW{afrCeuHXHTaJ!_pXmyef0yXoB;^{SU3Ot z%9Too+esYAS@ykJ2c({WwHcfRCvLZT1BMp^a;>JNi{f2h5QQN-f4{oMhG0hOluth= ze~~UB_YR`r+r(`b>yEV_Z$|_AXlQ7t#6VV$udPs^oN9Xb1Y`c#2J|& z2ys=HQ+zmzWo;pb;yvfBsbI}o-(Rf^-|wtTG_h|0Dsp59xuuldR8qQxBTot$VhR7g zG&P14gw{~g_@Yk~?hk2-Bj(X)if2(+=4aRUv-6{9RypC-YTZP8Z-R*S@|qlq9Z)$_ zyA+6%{)P_GygcnL3e{SdBfsy_S|?=az&64nK_z5AndN7)f8N|OZ_E(cB;ad1vrv3u zq*q5Pb~)G`knJ_IKjxn)^t&&0LPbqfC&J>zFpO#y$^sExHGTt}VRB;y{r%l~^gD@t z3uu!Giz|XZ*ws@w92~9%;BuFf^AWm|wDN$LaE`Tv;jQ4uAv!_D0IAK$0 zYhy(W>np1@6!|t@f>>bZ^W-3o7*VwjQO_q=vU3XwI>bD>wbQqLz@A$DII^vROzF8W zKzP3*9U--K%!Nt9271vXV3+s$xZUz_IU3p0?h>B-azZB~O;H2vT*TEjPFi_TB_YZT zBD`qdzgQ&AaH7_~5;d`V_!9OyaJ~kzPR3GHXuYtrAqGo@xnYo0vbhlprROZO%XpfSE?&Q&e_dn(j#n(yvr+)hNvX$aLBQf&W};UF;IE@}5T-({AG ze@J5nMqA;S^yTfL;(!`@=vWCgS|*wy^YDC@i!ZutFWrEGMEX40wLTJZsd)FA_;Kio zqgfSAq#5b<>akYzpB2ub|1;-9apj@71w5c5fSY8U?(Gi?Xwnh+cul zqEpM4MeRmVF40pZ4G;wDMl9k1ksP^oT*ShlP#Oi~5PttrZ%J`iE*Yj6I!-{644+V% zGHHdEx}iW|qH^)Ds>`hSTY3ElfI^(nFbjW4nD5q4wMI_qHj)P+b%_Kc)fcSj1PUmk zbk89b{R{W!(?o9yTtj^30}>_CIm3*LBrh@Ow^$%^f&wz@#UNGo4~_ZmQ)78Uq-oT! z`Om*UK2L;o|6dDhM%{b%G)JVM>e;hr zrvRzsqyK3qU8Zczuwh@3$R+Q5n=BZ%#8N)QQqKX;?lYpj0Elm@g<}Tx(2-QBdINdZ z_3u=_W0ncEbJgE^_eGsqU?+hX={$*+?o_sx%XaHsb7bnyc&iIn*4Plr2Ssi_HXr%}y(&J2ASH2bE&G?cYJd;~MG}GDv$%Cs;%3OuIyQ76 z*19J9VwW?}B+Vd{rQF(_EYzi#^_f3TQ*#j^#vM=`+ew4HK_WqX1xHGXouT^1 zt~#SX9!C+}T1h@vtx~@0F2h~~0wYIIea~(td5wIoT$9|gF}3NSu=C2>B!}kcdf?eF zRRxRgFK1sukId`WMfV;euCzK!3kUFrsI-?jH{^%_UH%D!2YB1O(3vsVc0~DSA+3Gq z``(6Uff+GNo+dLJ@duX~ghXGd)G;G_C%hWpxbQz{GZHfwEFrcn$_zi5kw7d^$vz9r-PBN zfsQ91H4Lm|-xT6swGE6A@{!JNs%teUCIqTrcg85OP0m6&E*xGq(LSf&ftT~Xo)YH& z?av7Q7a`l)3`IedU2hYyO&)X&9;>Jn$+U9(vqSr)8)u_aUKCTK5-_v^#R4{|V>|J> zDL@rEz~9$*@Ad}&CPOb(b9nH6{o}_$dEn>I0AK*ud~NY_ntkp7X?m4W;#5JBHxL1Y zgJHe^a9Mh2_`LPe73Q?h{2G(qo}KE&OahK|4bNS~lfWr<5P*zZ%ruy66-$=K5LjId zA5YaSfP%@xt+Z0w2&zHuR+;Mkv1%ucnm%)ns;W6l{WCfOsL?H}BS&UO9}d=j$Ez2& zlJ@HQKx;9KM`lom);RDeV;^@gxW(jWm;~tLJ)wMvkz}M#v`uAkgA}=9A(@fCRk#+=)3u zjY&r=kBnM;8C>N|k;-^nP@nwXUHQ(r%v3IcZrug1;-6zQf(#zeMvyKSZf$tz6q^C9 z1TXK8eblhAvEgh9p#+usZ~UiLhKx)bdX?qGNb@u1=`bk=Aa6Lyk0~REf!Z$4>k`&p!HQp3IC76V6GM1MIJYr7h@wz1q zj7iwdBpgzcwg|ZuB4)Cs=3dsDijx8%_3CB8&q~J!5DKF>ua@nktm}cCRsou%E!V6?_UgA)Z5Z(D}m> zYEB=tE&v(K%-j|@iM+1G8yIx7y}tGr?sI0ds z7X3s!t9_xNHpv}cUS1*>3;blDZ4pbCELrlS?dTCBWKgeKOae8LRc?>E z%9J*cnT7X8qgsi-DS~Z`k z+d(Z-g8~?|%9}6sPgKg)0PH201do+uSuG27@{?q5dVF zklu#BpPW~LN2wv%)%nO1E8Lu?*J$-7K}GgS?AGbBoqxibNgO-_4vafPzq1Cbw>1Q% zgCMp;`fj=MVQ;(QavTP$l2Q+9dm%cP#`MuzVMPk!e^mFhZ%OVu8O3Ta1L7O$MY?7w z(k$P~us06y`c)^sL>iJqcCp63nY}gASS8UtS*s5Lrnp=Zv78til3LNeAlR62EtUk) z>GPK#lVp)3+$;0V2;%67K^Ddqa)bTjcc27~@z82&we>Lw7qJtBqiW(g9hYUSHxEk^ z$Rl>k_Bl&7#WX!c>&F*?2`~sCs%-NhEO)^AXQ#N@cy&TwW zwEk{(CIXPY8v`Eo0xL- zV{4mR%DIh8bZq!ZnnWcz*~H+_Wk^I^NLGgQA28zH-MT7%-Ye*G+;A+gHe0 zBkfsRl0ei)0cdA$l}{hk84>LoG@|9VUV#Q{H=gI699QmSgqql%UOqM5QTCz4eo;&x zn8`BFuoF|(G?u4X_`GOrj1ftiOUYiOO*!5f97m4C-3=1_9jF%xz1ppIRT!Qr%7=6i zb8zA!ym=i}PnsIDPoraD5;a~=pB@#9xN+2pDM4tq(t>k6GMzmYUu+1#;*zOaXYlpW zFGjHwycYVeQYb#vG@kp_QsOhS6%1fqQ+j-4*NbFR?SHt5%d-@EF?=myPOJmE@dR8!sHY+E3o;ndTqgLXApi>Yb5}kOb69$+R!E z4+{L7kB=qOD%?A;vG)P<1W63KuE8{eqsR*{I@K-dLr{R1rS2dTrspRwix+>jQKe ztbTv>M8Uzt|4z*j>MM z>-CUhE0VX}TvJ+f`-kzidLmMEFKgSV9m;`gv%Ht9uG#u1VVe9!;rtUvEUcvM_MG0+ z*9wnGPHQ0uR|^I32y9(;=uGeA4S>&QC)r*<3ydqUfmvSYAt4d5AJtr3L7;3rU+v|k zhf5So#KYc2E2TOHeK7~8l?U;KCIep(Z186<@}%ZTsyn~Xx0Ar*JLe7XiCU?6drn@k z$3f9MmEmztF=^p2$(i)y#Ln1{SU!P!pD(^}*ti3MS%bID_gG&B=Ja{Nj1e^=oy))L z%eA1i0I~e)OQ&{ku>Fq;vyS3X9GlDg750v&Y$(S=FDfd66&lr zCrkqYsc-fe^oW8k6sMpBSTyHw64Te#ad*qsH&$d+XgpED2bCK;v%DK!z}=487wty) zJ}+#_Q}9v=9^n`KLe3G;7CLRqY$DW})-869d#TDl!GuJMn;xic(HBmq>K3nDqYP<*LAa!9xiVm2{KkkgY|q-Vq)VCU#2lwf zbqRRXO38mMLZ4w?)k>xQ5?O(tY6d@C=A~{4P`Nj=71Bqrt}F2J_;`oh<5ibqJD+A} zhlJY&Nn4=|UbMRV3yGODnm@GibNpm)N?0$gvTxB=KTuE1VC8j?a*Ne^CAo-2i_9{? z=$<$9iE6Gbyfyr2EDdo;(f(7zR;H?|DHkJ_9LbZ>Tl=0dUADK=x~s2aDMW-p9?j2x zA?0h@NivojqGw4mwl&**V|i)>fyaYBil0CNDdVq>o$#xNX`_zrZ!oZbd@vC??w zP=eImbQz>^-f-VI`n~2$`%`8*>562c7Cu`j94j|9Zk&BCx_#O%?`OugXQL+X*?s)} zF~=qQhE47H-SGYEy8cbCugB+;Jg@D&ed+_3Qq3NAYF`aKw8wwH-O~7|`73_cI(T}| zgUaWce;R14VZVOVrl@Czi_;gi|2=Qy%pr*fwl=&DZPIJgQdTIHWw9CQ>4xMY6B1HV zQkvjf5noJhGk=1QyTtkJNR~iIT}@@{+~(pE4`b?DUo#|lSeDO_dFTK|Rs=kdnq#r3~539u)q*#);lg&5I!-oQ-k;5a)6kG7kq&0xfn&No zWCsa$;0%}VlDw#u=uDZi7T{)kh@NqBa`JD47WSlv8fpi;_I%Ehm>BS5^Gvb-{XXW% zKKRf^kKOD^oE*p)ZG}biOqhr_xY%aK?HrD^A1$~tckA;0j8ZRz)ylnr5)(r zWJTPF$@1mPmn~mzHrDU(2vX*341_PapyBiUSGRi%o}q&Pf;;5Uu-^`SW?*38=;&y? zaN)uM0|xv?BpMbTJ_=rl(}U8|tz^f|&CMf>DGqqwPx^H4Y%Jtg zqx@?~AwA<+B4i_7;G|p*qj&xm$ntrR8?vXCG#armBBrC#4PUmMH!^72=E{RlMlTBR zr7|OkYFk>-ui6~GLHceJvDmkGy?36a;25ikb$jb?kG0Cdxlq$O?g_HwmG0!^w2;S> zv9+M6$na&mygc7QD#!S}Ola)SC|7PblwONxgz))5L7_y*hB8u}Rkkj<)?><)DJ2=+ z-sN-|r_$EkU;DJuVF;pp!PV8(!Ft=Z;8(ra?zwX1N)e$TPl1Rs(sA9o`HL6l&Rq6_ zj3S3X)6d`EA5&Hx{bYaU8p*?pii&h}bzAisS7T1CNRWdtw{|oTL_|lYKl`0~aKNM_ z44&gWdhhIEfH?EHlXB0d+`spmbgIIMs=|?}zR>?jzgNt&ZJR zMacV_N&rX1?+tXPh{(un(2mJaWPEp0mT^Rn=~yu78BmJUQH5iv2} zn3^u+R_SJUlJUfGW*a4-XI1F@3Z}j7?YfosH4YWuPWx*4ab~!UID4 zZ~}LbCs!gk*U`~AZKc_(a^uFf`^xG@qXTb(45B+QCjG{|H{kk9eO~WV^6CnvL`xo`Kqe;+j6d2{yxLpd*OxWRSWeB+(@dxz#`2TLy)IHR=&7iCR^ zpgXN=PhaqlkI|F_qs;MOo{!a)Yp^i|oGD0{$w>5+*JV#iYTOrI%UR-xDw6!y_vgGEt zdxwLM?fOdu!rD%Vlhfkg-{7#aHRk-3J&FW>iod~`(%7~9FvQ8%WuiaUYJe5COp1yLHY)FSL+3TgFDxY?{HO}(f1)fH++5g zP2q)eCmM);+^Hu|`tb6E%ykVf13C3K;t^;5q4fSrpNz%kR+_aAt+U_m-`-o!L{?TV z*qLG5Vu#l+2Y1FhTTY8S(UF^3i9-fXR_5IXi~HZFg-vzg)c^hn{MQF&>$89VQ1u+) z2zZPCeXe+&aQxq&z+mDMNp&=T{}6uh|8B@r|KEnBpHhUC+zM^}-Kw|uCm6lGy?uqm zr}e|dzb5xg`nBTB&dEvVyyMH10B0i?#&439r)1XbOmWUV$#;2D(f!w7z~J|5mb^KC zhv&Oa6`~(c1aeo|PWk0&SJ?h8jE|51!*KGiKS-K|eknF4rfa1`OmBhbuYZR1fX%Zp znw*?;*}`U!ij)==rPS^Y*Rrcf{{5TT(cql478u~dH5-kbv;Qxa*I7>^(K|lAxVb@5 zvviu6nD}%Y@n55QUT0@xbK+|&?Y$=U?t~-R69HA3BryIzUgpxk?0Y&g zRvX&ChJnH2&YfQP`-h%>;$Fgk|1gOjK0)&L4>Qk^mH#~%jP=C-Ux$2rfwU|>(z3%}9fVTB*ya5Am_{+k@a)7@!qcHKMC9TbZtI%-3syk!Q;ev%5w z+oP`>E2~bz;2wXwEOkgn>??c#ad#mKer~#YFsHcG$TFm7h;GFu#|oM zx~tBUj4+ju^HDF>bJ-U3$p^g?-=3$ajX{DuI(}+tJ7F|=V=}vC$V~C{n z&}QlWe7Ttpu%Y$8&cR@Q{wEyc1~)d!6Wq734};RWO;Ae>M20QkpZ@dI?P{yV#Dw(q z2Z`~Kg}i;6>P66OBbzYf3+#EE)7~+bem(rk{^W`?wvSyUb$pmgJ`e^=a-#0HAGKxj z8VZ(Yyb^>Cx+ludpAj4!%w_ODxveL|RkzYjYiLY#Zy=CF?BM)g$g@54V z$4Gapwy=d!5N05W(RU>la&yxsP-$sGLSK$I1>W3cqB4@8I2>d{ZSt%RAwcT=sx>#N zvQmC#GmAxK-m<9F$Zv#+G1Xe2U=;?dyY~1n@(SGT=baSo@5ek?HX#~9=~`KJj4T{F z_{a6WJ|E$KQ~a6%a5j6n79$+`&4cuTDwIfhwd^gjkoH9W_>stnc{K1#aFoC%%+JC+ zWu*?o{e*f}7}oN0%|h*U-3x;`*bB84CJX#LQ44oRN8gj2K3aZVM|&WTAj{MWUZ4IV z_NN5*^OA_Klj+uO4t?(OthaQkj70a+(T%YC=TFaIhH4T^`GCXa^!C4wAjfvy!cHr2v-J7T#hm~A z;|>xeZ&k{pfG{-9?_ZwPgH5FJl^z{6vf0^tfVUnXD@WSsbO*aR_LEgD;-a@Rf@Nhw zLzV4{z&8CBaQpYYREw$t%ytkCvNP?2{qtr|9=>L=t+j8Re>gBwaZ_X~bI=MLQuq;s z%hdONrLm!_DWubnhkqjrTVIvN;X)?k7ODgFg$nq2W!&7R3$@$HhQ`@l#s>v86t}mH zY%0?vWEt8Lk4?3w5~IKpy(*TT-;ooa=s;8Z^btL9gD84DMqyE(@N`j!H8zCI|8xup zdId-OINP(3$0Ooa*^afaNY6wS6>aFt-@K^8Ha=##kkOsK;ckI5=olXk&C`pNluY&V z`Z*2Zb?6blH8{>MG3@@BwXDLVGOJz(YnB8U5# z)J{g2p5kwDas7Tk0GO;wc%c0jF>%*MIgh|g!qNWzAdkSgnA5YnZYJhAdri3~4kv<{ z>haxHP>fk~kL~P?WXfzn6euyY)zts|xPCV)41{vTj|aOB)n{Qz%15Zj-T*m_u;?%d z6yu}j^GAt@q;<3^>8BtTMq0fWsHo6l#%`l*kCf!29ylLO0W-ay{LF87w{No}o?F4p zy64-w&5^;FS#vA7qN3>&Alkr14+Dod4KrEWtNGd4=D@{y9{;k=monW#;pvRr4|u{u zrf1SH3j32PEZ8C5q7UO^w9sKhD@`Oz4#|Df;wxt}i}*_8VU8?=kpO<*G6Jdr6EhlAEr|Vubm4 z&Kk6Ln=JUZE#BL>usCn1LB^6D_ zPc+e+RH0F6eV>w!-@ns6L$o7j zy>1cY3z{P|qo(-iq zUTtGREvJIQ;ACf}#*A3rwF@L><~;EuG-zR6X6Z7^=v{Ic>>sv0tpk_k{XJ1fRz|1R zHrmf5f{*IyyeO}m)-}SWQ^QtLvPl;yE5nImu&_A&pV3Kg#_~$^m7Y&a{=i}xB>5Wi z>1lC^jJ`g8W3Yv8C> zY4fmUY97tQBOS>>GmfjK6bvK_lACF#5%aURRMgZZ`Omb;y3W6Ji=7kqF{%GkK9KRSR=pHR#3CKX$Y;Gs$b)))=$)xRSFk99=_hUDJtsP za=9aToEWW@0ZM6lD>62U8@H#<;1}g6DIJ=;eY>mg=`$=avi`%!>`7Tr_`E5MoDi?C zsVQ%RqX*NI7nf^2kFHit)vIsV<* zY5=$14Kb2)OAOq|u92m`6wIN^qNFLIQ(=xG*?{cw-?aDI$T-csPneuAdTq}ox<``(gqh71{Kj;8aVfdF5ZKf- zA$BPK!aQfoKGS0`n{?gX`sB}Pn4;oXHS`i$5M|9XX|eoi2%+-0V+$ysD{sKs&7`KM z*L7u?0kl=;DIzL-+mNe%>Lg4Ym3&xtXMb-G)VR0SJD>-7jC1=`U(4 z_A<~$x*&1O@=XZaj;U9z$JGmb+{kEtu8Wv>@3QP;%0T_f>0!$A05izR)lZ)S>pF_` z+0vq%3W{44dQ6wPzQe5rpQLm?-dE&5dlux`>6PP}Rh%U^Uyh0jzfobQ{EjvM^Gj1M z1#j~Z8J2KD4mucY_VoT5WMQ7HT)b1Ya3LYnrm%*@NojyHEiCZ*czj#qDeni?&c{|b zE5~;m(>^r$`n9s0ob~2JrWZk0Nw4s9rO{%O)hx$<4!LNrTc7%3le%n!q}bhcEAj#1!jDOL;S?MNXo8Qo z)$*ua*y0r&X~mKSosCq=J?E1~M3FkzpZ5CXqCOwL!g^e1r?|>N z!~wtFQ(nSrV%93`P?kAlb3)-fIWe&^{c{fKrO)Ne_J{#t)Jd3UH#lo!K3?9mnM9A8 zk%MF9welFRdBz$o(YrFE@k{iR^rK3rPO=JPt}!%#^b**Gg=cpEPLVF(#G_VtjXEqQ z_I2x7^c;>?!N#28mb`*YkciRZDhUjx82JAT*E2;xD4&Z^Wp+X@I$RH0T3AT_`U1kc z{dt2@^@>Vz?CjI8j*};hwrRCEtOJP#bu7r!EA`Fq17y_lT^4Vpc6W_XUw%#iV?Kkn z*C`v3NpfHam1&$@z8Tbk!I&5rq+YlNZF}!0_y^084|x1MTD$z2r0z!n{5oc4#7gBy z*R4um`G-%trJ+Pj^m3qJAY$`#PY;>7qCf>k!Nj(U)_Cy@%+n{I$>=&n{=rl;qp$7% z#0Os_m-f%C(1?jDpeR^ej9vJb9gAxmH2%@Sc zrQI^Iz|bx(M4UPMx-|n-?a{=iVy6td|N%e)Cv0!g^o_Ihd0#CoJrh21dgik0vd|K3bt4B$WbUqsDJZlYpSujjg56( z$6K!IB`>L|UVxU8(%8?x0=BZ~WAwG|B~bpxT{t8{;F2H~?o^AkzwB!19AsHrAD#p$ zbW9gYmxmAQ$Vi-o^;G`Dmb|KlAgTIvp#tR;Rpno{ugpVKORjhtJdzk>Iu3{T{haPU?P=Ad=LZm;}2ZQJ|K< z&XU4lfk(AsSbe=$nEcSB?;C*rBS{tWlJ8Se6`}k4({ghs{`|W`5#d*gNGH;=e6hJD zmIhxD*!9m~r?-KJdmLfkI_Su_JX}ny${g3l4Sz30xVX$OM_*$}B!#lW!6RhU-c5ui+4R2P^Zr=bqlN2r>buLc@&?a^!&WPPVMP6tc3DH%ElGv6SeEe+Km16{k=rd{ml+DTU%xC2leY4U{cgtu2rwn-Y=zD zvs%1a2ckVZ{L1c5$9}cwMm?#io7?D0R7Qe}tk`b1SZ-PM6uYqyL=t#DtH|TwHKY?B z?0hcdlH>wH+U{=GpU;l2E}Aa$cbhOrJ}fR06<>k|q|Hm7a&5RfpfWB7s$tbcttjaO z0?#A@1m0U`qoZYVdchApDVy-T)K!4G?_f2xV72bqfeVQnUzt`%>^e*apWayZq}%YK z`@Xo-zL=SoHq|3YuEiCtIx=b7T~Q$z@cw<+jhkR?Nw#ck165@{U%DoPipq5YK;<&~ zge7!2kd#>F%NGcL96smzrqg)@u{8dTZM5RdWG`hiVbSkbfBJ{yCeG>y0qXDos{BJ+ znh-^@VElb#B*)kHd_Z7eHVUQV{owxG+}xIr$HrN94vsNlj>L{RkG+oltgI{+w~a4! zPX(w&@g-s_(H*}7tXxyL)}KfU1g7L~SLSzbuFRBFRAkj|SJigU&d#DXw#WC~Ev&5O zQs{OwAM7Yy1*^*h6-|2GC}VI^IZD&}OZu0VT&=O?MhR}Cu+yeT%g z&}&|#uHqi6QXZ*F?telx)z!bxh^`B|wU)WICeL`RrqK27Z_w>e4y?3cFj$P0`%3ap ze1G*cugh{H#abh$`(wJT?>?)|O74LEvfC=r+vb&6{N%nlfEG=6tXYX~+)jdwm@HsU zRz+o6iIau~B1~A4zX=JoMLp)syRD!!yuW+wT)h^~8nPKEkTlZI6VCS6dG>stpcx(w z=i_^Y0T9%5qMSo(9^GtIDEA1e5=mTgrxp zjuoo6&0p!9qJzQZAe+(iXR?m@=^#Vs{a_0-zN1i5Ts(p_H#3t<+*{4a?Wk~GNq660 z_t+oXRcA{F=uq8%_!bs2mN9&3*=SXwV#ZpYBWg~y0-BgP*St^EL77XUgRHFot@I;V zhWTZKE?1GGHNi~LJJqOiR9WOthpX}N%E&55w$Na5ijxp}_mlEM`WBa!&6VW4;gZpo zqm_mtdnf5OJpZikTCIa~E#lCvcA9r~pEh=%{=Q4<_WPlbfPjEuDKxn3t>|J-b4Le| zTLEIZG`CR737=W%8qqHJ7l_Cjd+2HEtOa_1=~}V|>HhPrOCgg^=!gjUWKfOYVYcQ> zUO3D81Xx}U+Wpr}Izhy~l>09!MMPk0B-a>8-(>{or@NCZ3HY&Hl1fK<4X&-l<6kUdj(9`xZdOzq;Asu{Y+1 zwpm^6RzlKlLruc(yG#jA57^n+nMC_lltk=*@A-4qIQhvRykEm?_BDmsw8F=fSI_a$ zoick?w7-4w4G8_cH>o2eCFhq1HM$?2hk3ey6Ftwy#`b&A zIPr;SV(t3Cx@*V!OIO#Cm5ono`LvZDKN`GM;;ml1Xjor^Mmu#oGIV+dxBTdpH%@a# zplcvXq^6vih8iHDquG+2A|lh|n}qxN80{U-#E@jm14MC{-NM5UvfHJ{6S}7=v=wjP zzP;sNyFs+;v%f@#09>WpW~*Keg_y@)wfiK$`u zK!6GgV(C18Mkn%1Ea(aer{VG9-S?x5OJz~0vAg}@Mn;gMA3jSY|8`>*u&NCmO%lh$rH{2RFz|=P=*i6<1(U|DcL)f^rO4c*ZeQ z7f3Nsh9In)o3e@uuxX)^(wJSZwY8K&*DEM~TfL~85;RU#ajhGa&z~NCwL0t-YP{6Si zVldE>#X)-=^#~ZW5_4k5r^3R=;~N3vzmfB=PcMLd&k)s9Q3>Vamast++) z>enc52cXpA#(d7|@05cSnRYH**voX)PHf$-(r%_5HQf72Z7tGcGjeN9Z{OZ+h2Nuy zfd!x)D6c~vGKaJBsQR-9 zt=zZ3&hzL=4G&A{N53C@O-V~~4;*ldA23lt$Avieg&B9n{ps!9?^&} z?S|e$OG`^udr4IlGPMp>B#pZP6cfE3e%E9hg&-;nt`H*AjcSwwNEcMkqM7o^A3!^+ z%+eV>Gn1Cb!9q^N2mKoKc#hgASYGmlRstaCC$(GsB9vO%VSv|t`*val5N6s}b(J5C zZ==SMzxRkZtCKJo%uTdTwbSzVT`U%>5rih**Rqtdto4Rb)6+%)>KsML?$|NJ@4dy{vBmh`)ctun-7{kQo5*!7P0iJ< z{@T3@gU~w&1T;#hyqix;`7#2dLI*cB%`Z!yNu8O3a6~Q@&ip&l9UDm^g0~pQTlh7;NI>t`k?wdl{8&P5126H&iRHJVMJDWT z>Fv)YZ(F&|Y4r{aIK6!j1@<^q#+&Ty&S+{h!s={bH>l3nk!XBvCdy-!mratK8R?k>3w42AqM@^Im*)u zXr~V3SPG~)b|*;pl0@-^K_U z#$j)7KU%fl@3Gsz)n~Q)RHw=T_uU4I(5&5?tIab`bi;q2Ty#PU^Gx$kLV>LAAwb!E z{V4t5cP#2>6j`b9bi6|R=*-99-=ODQh+b&yo_oy5^{btkJUj+L9qnf#L2GDgqC9Ud zLfBUp4<+KQuE-k1V$GyLrS*?jO=xuQ;9wTOwV?b}P*R$k?ful^(#EvazPO`!P#!&e z_@!`WyUkcM#bYOEzmO}sE!hs*c~pC%SblCU`z|o$+^0{U2F6W7Wf3rdhpxq>oYC^E z3pQD^fbx)(lx#VWb-}g!^P<~_bS0$}&N@yMTaJZ+^U)t2?W(Z*Pu^I23A!Kdqr&9A z()mu_CfX-XCBr`eokW+(A|REGNCCqoyIQdJHCUP9Nvn2$FD91Xeq|b?9|V$km+<(e z;_kM`{^FGqOq@p@z>g_GuD@=&EL6-aTq&%|`^4$K?7#JsqW1S@+~Ri4Vt3W}?!sq^ zGAL=4SXy9oN5*;>4yYni^zTfKRQxPqagAk7>Cn)t4zQ00&#bSW+We2_e!~}Y;L?8R zv}T#bjgh#XL6g9fAW1LH;jS*auUDgv*&i=2&oy%@hxAi(}x77A!b#!$4CignUwxqU}e8h4{T_;YOnwSXo3PRJyDJDN_ z3K{x(7$i*P9=--m&!CPr={CKijO*E@p%sc>N9pra+^+y_V;pX*(EO>U`Z*rZ{5UZQ zYO-HU;TWT}E;&vt9yct@7&OOG~yeYC*ZjuVv&s)v|EI^T)$-G|pp>h5_!^5DJ_McJMW8+KsE3RElY9?lVC@}9)=sn(l7qBTn%LgrZ=`MsW zNn=k-Bt_9*G%@%}n;0AVXY*fT%~P`kWwGc=69AM@z)d!=*kDb~YJF^RaWTmApaQ#e zNcTM}tYpP40-`=9b!-eA$nI}kxTY2g$gINT0rv?_1)d(t{xvIGZmtKRRH_M&8fdlD z?;ruQ)^p;JRjqp{$_X*czHfdB0D^XlTgY^uQcEKkkN*$iH*Ie5Ls(DHn3>!i{p=;% z-Sxt%PL(-|rQpAY`SSB4s#O9gvHHkg3S~Y7dK#$NC1N3T;kaf}WQr87X(one?W7X{ zBD|{VfL3QY+Er5N3;?j8onLkWaKRmHePNU%TX;xBSnORLu#PLf z(qF#dH`*=`+k(vvI^0~RIzYMpuzDtL`Vumle7H1d_(6zBo)OAr2T#%vZc*;jCy2a8 zpwF=C=p{y0Z9FIA^?n8BCJ$v%bxLN-Iy7vSJ29uCYSALsk*@cZBE1ca5p__mLx3w!nVF*+9b#nl0%P8=G`R zoMX->xdXO!;(p-GfB>ksUa`=*(c%})_3ZYmqjK>?WV7_yvqp&N`uf%~ZAC&K%NSYLo<8*lx&fFy zXM99NBubynJSBvOS7vuNz57EX)&%>_TBD;I4jwFNAnB@$3RJ? zz!U=7LKPLvEGac@n88}=?X9+<+wj~6H;N*80mlfu53pYL5@5H94tKi;HK?%|I1qw$ zx#)j7mUP0{NquNwi8d`(Hrk&Ts4tFFgME{I8aPe+-W?5D@RAp18ea8$e?~YeEPM^+ zdwFn_*DPBXcsK-0J(YjYhYby<;czL1=6yRGsmYgNNip#M(JB}B=TJf0`^v&&7*2HQJfK+@(-m7=m96rxy(55$^G?*h6et3WsL1}#%9J9M zQUr=7$xEdqulB!d0eVXOe03$s6~eBz_dqVQbkv|tk~}?_yUPOz0K>)+`im;_WBp9L z{E@=ks_#G()MH$@ug8GU-Al7`fEft9<~(Q-j!N@C8=)Fwf{oc49UTx9G>6Sd6kSyp zithuJ20Z;enAx*iL*s6!1=M^K5dmQ#PLlpP<3GPvr1Z74(l=0_Zf{hB-vST(ArRN~ z)RaC=u*78qx1vTgYBJEp(?)I2by{cA47va*@p3C@h?|E2R0R9q#>OImWUoXVoU9O} z=#q%V>btu! z`ksTb_p42Tr)moP>j|_&_Wi-HPntLnLLTOP4*sdK3PUzII+{|57}|-Vqa+mN{7)y! zo++G*2&oIPFONk)6R|+AY8q8m_POCSWR>6%NCxoOWr!^)0SM@Zp0DF&b8{P8(KhlK z>ouZwtyA)a+f8qaQEq=;tef|_YPYtg=h`5V%eIdi0e9fxdx0dz?5?L~gtRm#>KBcc zHV^V_p?ZNJ0nD26u+5VxTvUV~`2Ha}f=JbW+9<1b9HG6;CBm*#BX0*d9q3UfBQzpQ z${j6HPzhx*UBn7%`QW?#9<^1txU@O7SH+K(l`8gGh=zv%tSKZUpN!PkZ&s0XHn)h5 zjeOYyrYXs*7}Tcv)w`4hzeC{_Cr0P03oL-_Fr&`4G`)>Bm`h8pCnG%BYveTGYGKSJ zrJofx7)yQi9JE)^qgoDp-lz%ryt#GM66fYNMMHI!1Ta+7Pnn~F^xbtqNw`-5j^m`O zRlbJ0KU_#fPP@OhS>c{#&3iAGJNMXf^JC3k0oSO_$z_KuTj2a&E5yGgS&rbOpMPoK z%YFj-sewbFoyatva%h3#G~bNUgdJ10$`nhjf!>BZ2{4$HbevW;+pibMN5$|_&C3j@ z=km;kDD_aRI9#}>)G4E5)_ywXT#_!3Dt&tg^e1NS)F)tYU*=KhUEur?5%Wl13yT9b z1t!r89DlhQ$nGwJ_7C(VmGEL4DHOEEC*OQYf4NhLmhZ<~m#=QdhfhXP>n#(SSbrZ8 zQ{=m?Q_GQ?7a=MZrp-FWXU02x^*^BI2>m}u;5OyUFoS+~;xHi&qa z6mIh*HnGgZ1ehTP1A>O?3ACX533Cn#r~&=&i9X;msZ>W|=ZYNjVc9Y~E<5F&q4PS2 zRee$ukTjH-b>Z>LXi2C65A=we$P&|+cj&&P$tlaVE~E2vqAV8%&9Qb5J8_G{RLh`o z1@Y*x@Kn&FUcd)Vtr(FKg97DHXy6%BR%Mo0+S+~3 zJB4m;=_}60#?9S?@^bzxK>Moe*SHfjIvlF&((Kv}e_~{eD@;zFt$BKq`K^;Sp$6+| zH8o5S=<~9kKQvR*gz*ME#C4yFB!Zhdq635i9bKKHy$`!jo|T1#H%7~EOxf&1HT!Me^FXcwDFI;N%#^$o$bk)98UYMW za^#UFW@bh_SwL~#{o!0DF9x$0%h%lfn{Ih#B2(!$>~Z6pjXcGN)<~Q_ftd_2 z-k@#AcOTkj%mH1WdWFy{&8Pb|S!#tK@?P-Le#V*E<~q-c-(OnC5(a^c=2(WAWHhyM z$cum!??6mC%*2tQoF00Z{b8oxM}L~vX6rR0V9xV*ySvK9$Yr;;Ql)6`vIp$u$^1j?^(3W(9 z6Mf~+iM8yMFYZ62IE?W?hm(2gXy;_G#rq8o_h`*U#RU-vX&s%h!Uy#{e-15AJOFqz z5ESLI?@ziQA$5_pKvXrW29GJ>E)uyL)H;(HLg3?fp#L66wcxM#x390Om1iZz~4ik3KNHf+l;uyZ94vY zY(S@Rn`$n2GODB5CNc8C{Yv{*1VU;MH$TwNck|*(8cCfNRBD2{ODAR$*xbn@n`_6H z0zRI`UlQl*(otqEXa~O>DHaD|zuWAoM~l;9dhX7O$b9gpj~eU#%W&8?CK7?@q$PNRLKt+NpNae&JX) z*g-HmxKv;=G<6GUTUBViRVs~i#6{ftH|i~ zN_)})B=%%#oXH=6-VN9g5hWE4V*}{9cp#;K!4{5BMLJD=;7s6ULYb5l{6@nGq|M=> zTwzb-Z^T8v-;Em6#qKy4U47#-DKKpZ)CXeImcdoywdeg_IP{5n+dius8#(D&n|xz? z4Gv1?CQ0a6uOEtFlO#9nKP+iQot#yW@^SlY3yPUGV9$p$C}sjh*(lejs5#Iq11WS= zz|V56Ut?pIVvM25-%wwHCNDWRQeFO_QcFsI^JOpKq-SZaUymT)zI!0wOcy4i)%>qKU6Pk21NCVu@*qx29DbCi zOFnDt2ft%8Ke-3!;!*X!zSQ{mV}iQwWJJUc#r>4WDkHQY52>Jtd@wWB6@%_=V+q*G zAfE{Nq5Lbqacld=Fl!f3rt7h2Y3+S^1lVN8!x~F9w?c5c!9gz(%R^9?2fD4)#psL- z6Q09T6wWs{x2KO^AlF2{0P^w4g_$v{i!N@XwQB-_C1u8Ry8n>K-Mk61e$Q)bb;!8~ zHSnMctUuJQia!DO7f(v9w9@uzVu)N>p#&#gzzXWQpn!f#jFPPHVXyRZo75D=8abu_e!IL#04 zc0hQi3Q$;O{pOS+-|W*s9o&@$m08e}DeV1<#S#iCK)Ojo1NP4Yu)}w6=+rLkEc~vHCVSuDY^}pz++GJwuR$h>69x54W^*swY3Ae5@dU3J8Fb+@S*Xf9}b`jX?|m zvbsk@BVo1`DS$99dWUJedAP5)__!y<6gh$H*acWS6X5wlAoIUmZBW$pD;0~UB|IIY z$s3cnuA32-3QBU62%s1$dGE1Vm^*ohSz5{t54(z;IJklE|8(n<}|Ev_9`N8&kURu@~An}&B;qWY) zTi`=xLjAnW>T7~7d#=azaZfe49ab}dK)?sJh=H;S)Lw3*!ZoEvm8f+fQBb=Q9UrdU zFU%*ve3-2lLD@1kvbWc%E(FvF(TfUzs|l!(f_5|eEdY7o9wbCS!2Knqa4I4Ed~E}d z4|kgEF(l5G^?v1ek3410k@p%^sHWyTNO2~{Oy#cG-&*^<Ht5^NL$7~4TEcf`*l|Nj`QV>__?2+Dx#zjAm_PWYAX(ji9L^~E!REo1>P^p5D|z!}>;o$a~rT_LFH+FXU%SwfI` zd;;D}1A%9o)fTX8V~O*Cwgifq8Gzk}T0lBAM+Z>r=tcmh@+h(?G4eyyr$;Px>81l zM$X~AC4nN>F~m|SdjSv628C3L(CX?2=VwsBSzfZYv}_-1s{ts*6k6=qP7NI?$%f4t z7&FIFgex`(@wQ0P1{aM@#_m-XTsJI&?hIsF9Dz&qs;YFafJo~oFn&+Nk4cJ8-PmLP zIP*NXzdM~SA}Ykn%YQb4M79l5#v_@|_lH}Km+CFSzd)J21nmP+L!K?2L#+0WNc10P zI}CuYjYkOC58SeCdoLo&)zHBA&l}K_`_wA@lzGD=@i4+n5L8tenWrf@mh}vSJ16IW zFZw}uauQm>%{IJEI zftg$fyr}QM@GxHHi0CL+;xHDnugY_*28n@+h>z)1M#bR%xTA+2Xc=-Oashk{6r=Zo z3-m}~N!1@8@3XXmfURf$pTduoglJgY&{q=Eb1HUFW5w-gU^*2QWj;ukE$?HcC8yo< zHh~t<477TBkpMKcX1oU%7ZTS4?H%QEb3urmKx}Pe>@{?iS-6uy8wxOy2Z8R2@$-6J zwqbzwN`Q01vhq7>vcg(7mHG}%CKLJTQ&(REH~`apvPTxa=v|5m!1)Y(r7W$rs<~DD z=E1besie<>ft$UC++s@l)UdiQhjMUn37NE1(0{lJ*6s`lfDERbJXv93u#yAAfnNbi z-V+_^W&H@eq?+c>II&l+F87@AI#hPTn&w;Q2J)YTjcn$S35HS*>v|d z%5g9$DE9q&F+3DgTsA{v_VNRC|Lknt7hg0^tYxQWoB$?3atKFRo0{IDP9oTvfOnoh za~2~R8i~-<)V^?3iFo>zR-5asRu4B1KfU&Ds1KwEAR5mKs}T73_SZq_$8-sQJ_N?9 z!e+$CIndT7od;cL@*JwKVt`h7B^ka%_vCj!!3lBe2RHWJ${Hn#)(`g_zTRcBZ#ouy zF{|)yxhvecvT9ej3P_AprF=o?i(Lx@5(O&HS&$a2-WSz!=H@{Sk|aJjEo9G0^la=h z(eE8|jsuSa;6s#x9NX*_qzDvy;6Es#9;al4$70zEVHTcR_KFAQ-g?F&t z4Et8^b?xOuqm6th6%1&iQac|b??r2i=<@Ha(7)TES3#9Pf&~puuAIji57#`MB{Q6{(zzc3J z`U9Cgs~&X2>KTXoQb>m!@LKOx!m<)Ws|R#PeWxUzpElb;g(bY(_Iki=k1SLJToi(Y z=+ciUDWR~()IVxb`Pr#?MnR3S$JaICTG7E|(&-XwJz=OP_FA#nS%Q0+Su&7-T!m$& z3#bKKy3H`0lGLAXz#aO+(W6s6dw$u1fahTOE_$r#L_#$!p#t>l`g$i&OOuV z6`qZJ5oA|5!nw+-8s{oTT0K0L3ahFvC4az*&)EAnUPXZj2H=kyxV1Kx;K)W6(u4-+ z_(^(|*3dX`@ajo$!TaZnCnfj5R}DaWSzXS5^8-Oopcg@R?(W3IOLLF$otR%joUl3> zIO~C7m;)XamkQ{QtTKL3(Z%ULd|h$X(6U_^&}fy_-QHP*zif?innt5L2j{VRDR8HX zJA3y7_5DVuC{vpxSG+sN6gv<2izJ7`ix5ngrcrk%j19i#AP%^sN+B;$HF$0Ftox=w7B_aO>vc+WSD|m2;~8d+q>V zAoQH!d}e;*yXm)6EQbyTdmf1(%p5E*-u^S%a!&T8=EQ;*};i~k{>jP7RkEUm! z&?7R_^j1PH6AZx692F}aFk@Rg?KGfq-Tf%()vZvxmG78tR)rvV?^7wLQMOG>bLxPp zm1*OXCjm@BAKOD)N2~-JC-|O3`$chkYigA`cU(-?bNBDF*_$<%W<;X=_pV2Vf&$HJ z6JNS}*5<<|5XWipm^z36D%$msvC3|q&5nLQeT(eptVf(81HFQL)M@^F!ev+8m^dDZ zg)2frHje!~jZ2qEVkOsLrfT;rT|PPOp3~Cerl=^OI0sw0%<6cMmu8h%4Nb41-aG&` zOK)a{2IbWPw6W3rXv{yJ@=ZH8T{m0PV@H}KH~oj{!Z0y;3;lUAdYgVGlcBQV!nYyQ zfdxi3M_qK_15GsO;)Cf!l~51=$=4^ln@2xQK8mi$)A0Lzjh2sh2dsjPk(hXJlAHU= z<|GmL0?lE~^p8NTH?ICZ-UVm~c^G(koX{jBsgQEitL^F>)@_W8mW)YapkXN~uL^@RSV>aZM`UZkx?US>0E;Jbp%GCcd@J4z^%lX?MDr4f&`gvKr=LBfjqOaV$^Y+ zk{C$O#O;ru<}={%GAQ3SgDV7Z6ez6|Xp73WulMuXw*-l{Fg|UbUyN121Oyb-O0pUG zeH$K5E9C=Lq|DAPMR%Kwgra(J5!^JIUhbAo1MIiF;&OSA{K}v+1gKvs}CM+rG zuvY&GrYQlSECGzJk^D!{8C)rON-%e8WhMRFs2teNAp*GA&@g7bra#19l=D_-*M`%C z2>~n{c9^?P6cs$P`ZatcvGu&_L$jwob2pu zo=HwXs0KdYQGs;BfcDz2RK(_=)=+%QGmr6{UFY-OZIw4Xx9l7{>ORdh55@Eh-!3VI z?qVc;j^FYqson6eRrk9`+tRT+(h)9vP%EPa1U`V+rVm)7K#=_q?o=HtUdvPS*Sgzy=MA0mf6PUB!3F%BokSy@)a3ekM*OPkwB>z{bz85x z_V(sP3Sa4m50&-w4BfRM7xo+qX_euu`7KhT$o0ha;lujrH(Q0}FNLHBR@cJQQrfmE zQ9mTu7)AD+mPE*5swDm4dAhvBh1Cp~E{GC%YKDSulB_eI5;PH6j-I(xk*C%7V7F>x`s&U~N2D;+a8~uoWk&{^@wDiY!aqq$VRZBR2Rd`vi?F?;G_JZ&I3u}1 zrOIKW3mVYRk&cdr6rNJ_Mwd(Tm1Hy0Hl0_zZR51ti_dB4^65F@aA_S^ptZwm0r}sE z1MNi-0XQqT1j}lu#|?U;dOmJ$fH7bm5ayOkw+{d5kW@1oKkYjC7U~IK*m(~wu7em< z(XKtQAP}fHxP!`UadVgc_XAc&bI>thb|$33)o`Np4p7@d7Hhc ze*nEyYpT?6Nbs!_*SPf*W>n$b?laDy5eyP!pSPygNg05ZYqWdEEF;okNx7KSXUki> zF&(jn6M$d?ZB2MI^?KNopULpwy8Ww=0E&|BOE?-x{I>QM_uXaEzl(UpJRV`rI=lzs zIRu=vlEVqyTI0}x&_}(k4tC4l#HvGhtXm)NX7j%4)ApxNVEJi{h?VTL(J#5|D}n`> z0ynr;>>zRS)PXl9ssC~2&TD_#EG+Oc4}bO*NWGjWgG9!Ee5C;`!a;T`OflAqD1Y`Q zI+zyOc7fs)ta*oUw?(a*sa6*HJVu%hOneOq6inP}(snv(fs?Fq!V*@ zcehs}bZ@T?3-N*M&DDG-~#meI_9UA??Ka5`i+?=%xR@+ z1LCC*q&)EG_SJ=!tPgUjthWx%L+S`pT1UyC#8KBMLntXBwNsW@lbbS2H-60OLX(by zLVAIlb%FcP5NJbUI&SMemxNIpyX#gucaIq!i~dI9*tH`lA=n8Y>^< zqn-~2%8)vpm>97lzIp4?9)$)&DE{f3ad9;p4Yd^8mNB zo;|S+G|<1>ydvpri1Y3A#t$IQd>I67Xu+LUh|gR-*Y+@Ckw71Jm&g9Ui>9*l*F)9&WoG8_@8Hs>;n>6?_t^F7LAX zn45f00Njej#7;*ZmQs8`CeCXZw7#~yM;(5Xl2>KHy!Yc~wMov04zbm&5E-P$+k}Kk zB;dLY+|5A~5Fjj`MgmWlCd04L0{mE`i}QmV9gD_K_EcF9)V}WCsfMawB?)VtA`N$K zwPoqA=F0yUQ)dBG)fTVuLrIHDDczxTcPSyAqI8LLcZ(p>3P`8Yjd18zK}xz)kZ$Qb zZ*BCx_Za4mb7ws6vseA&`+h4bGD(Fl%8Bd%jgQmua@E3H7br}{OemmF2rvWiCr%=6 z?LR0Vv+E{{$tQvPS$PLfjk6v!qDnj=A-UP_UUuBf+d#vz-fwXG_C_P~ZPnhT%V?;f!5wHGo@Z@nJg+`;F>3FEUMJ-x^%o?ydC1|CJ#0hC4F&p z^xPj!JEeutBf!Y4Uv;(=+WE}PF_SXo?bv}XI>r3dAIh&AUtM!1UwHdi{19up3u~O& zeqq8b&i=3ZL)JJAg}JIcovb!cSsWR%a~ zH&J4*sdrEEYRR#4F8r^v<#TH@O~w-Ro24Zu&mBM;2d zrxS??=@E$>jF7(bnC(rt>U#!8m6?|`Nj%<2e{E2eIhe2*P^A2Y&&SRExAC2MiJW4a z1}uPhh&?S<`q^e%zB{%cGdr^=y6&6=;1{rjXB#bdmE-$UPJ^){lA(4{fR`qd-0<+R zhrN9yt7hg3a8W4lKpqe72O7Vxf6zATTLHMjP4CVUK)LXW%K9&hpXNk$fV2ZJ4;(lk zeaW)g5VHHY>k+#D9=aE#TkrSXaqgaGTNa_dnbHB>vGPwJJ(}a}1bx?lmJXRps;2S< z@{II&3jZ0KIIX5pErgO&SA<}T$DqFt&rh~{oTSw?c9X(zVyxUBz9xZ>s-O|goCCQa zmJs`3{@*qt4mmkcocQ8w?vz?aitw5Hh9*6@=)t?4OwS6cfKa%ajFfLcM3lW_=eGiO z9Hz!wu~g9q~W3;-4S`g*sb8>}Gvl^V9khM(BNXgIYBurT~W#$qI5nMi#ZV zs5^t{aeUF-)3E83lpKWwCOdYx!-U?Gg>lDzSEZ9Lpq=x#=^i&emu`t`&CO>%r-3|b z;h?&)@ugE+8|ZzlE$sU*EOBwoL2?|H10Pj%J5py#^nD7G@MU`X`l7u(Fx_+I!4)uy z_BAcKbiRuFKp8d-Hr9Y{_QzUl(i=2Tue9{O74&R+8qkuIdCzXT z>@P~Yy0|diW9}+|4ggfZu3K5z+V@BWi-vI=N;0AG-oH^#YTy`Z@$qE~yI)2FVJ+dc z)=8U|;0-ze4QF%ncquox*Urx0Up49GC<&}Cr-DwhPih+9u{9f1<&qQM8+bkKUT%!8 z^POgC_jTpjyllK0h`L>R0aGObeJ2r{-7!GDfx|2CFk$f0HLaDNo*qc>?o(FY1cz(w zdiHxC0*e*Vg(ftMx-A^lpd-}Q_Ig+uskP_FyY=RnK8na3^_5j+Ev2^;Ga}8kz77LE z3ru)7jcj3RP)J_d*~wP@eN+B{zq0RV5t@jInwtKBJPJ{QcKGcQ*In_tS95f0vK12I zx`W`2TUT6BUtK9-@?gc_jL*!AlPKi%mF)l^7HFcO=B9cl{9; z%y!UP*6X?M~j0e$jAT{&%%7Fxs+GHqpV9978kU1x=YN$mV6}-lh}Uf z_4?xSvXQRKkxakVL2~{`e_m@#1A0YFl|V_;XAW#bH-$bc*;jeK$ln~je-fI$l1)xM zWVfTF5NpmPX$$L&ro8L08nwO!Jvl5N7aQB$CN)7WNSPvEUsSZ&T0@sxSAJgEtHXp- z1EdH!V?#7Y$6k;#Ckd)bN|c8gETngt?Oa^}6fe_p4-}CwRf4<+Wm+!CF#twkKx3S7 z+0^i8)8cnnd5eA6G&b4==i|qn#Oj|#fc7-2K?%4RT!u-Y)(xPdTsQkF=9mfT$ z#i2BeDOm2?miScf&-0TMZ~~TnBChqH9rvAWYUw}MYKA^9Ur0gWI2Yd6cg*=3=Aa`g znvR=Im-Kxjj8rtai_GwFW_%R_S9~t(Z|U(9^7YB{yLpOb9lbbpW?&^)^#8@JssI%R z77bRDLCw6SjP%P=y;WjLTx{PD$IBFT(0M+D^p=ptBRK<7bxUx7!MWx&Jm5`EOa!y^ zyq&l?6F6&4ZhABl4?xqkJy7&#I$nSYDQRW2@Z1#ObiV29+_00iZ>j#%)O49y45Hl? zdF+%~{o(DKAX-&lyYDhyBl0VzPnf4e`hDT7g*^+A64wfB{ejE-DI0PCy)y?^`jk|5^5m zBp00q(u<&@ADh8jiAGwzD&Rlz$q-rdOK@tp7!ol^R(CU7MTaorB(U2kGiLp)^k!V#B;I zRZQ&clxeGuK;ctS+6AZuo^LpS%*(b0!@l9J}gQu5Bu ztCFfSgIxXMHjoEGVvFC&Mk|6%>q+p20Vw_?1thlGj;7U1K_wHpA|X> zR>Y0565Tv6@^M$@8#sD56#)I^@P&ex2n*!op#!E1bacp%Ye_*k@#$zL)!)&Z#T+Y* z*{+Ngm{-mY0Ojmt`*bc(m7_u-;l?L>li^LUvQCCie>HyiOLg4*73K4dcTYY>spLCu z)Yl7RhX71O7MJP+Xm~N(;fE$Jy2&Ju z=N`LR+VoQNLt4SU4CrkJbUQdW_z>gGb$(X1wN09SGt*&CDAPGQ{>sw?aHg8K_4Tn} z^kWlDxHuCaue$U=4$x7JK|X;VVmxK;kO81h<~L_{>UWatq0bAf`I`|*QFocf5WwOz z6~ag6?E&m6<(4{qepoN(gxIsHwbWROEj0Sr3l5OMx@LR`Ms}@5O!E;^-31VfyKJ@xE}o`;2h6r zAm-C+v729La+ZZOn!uCA4?Y8y@9s{FVY9mmiv4qQ5*o-4yS9oUJl**@#eH=Tcc)(p z>`Aym=%C*s-ry3-dk6Mffv%UUdAz?0&U>(#KF0%7O#`Q2b7LdRQxKi0h@E9q_+RdW zqmOX0ZZ&<_xnIsAXnMLkS-SPW@pJfGzDc^!77mm)ClloI|=fED8(grS90B1?tOS0B8ps*_yVQQ@#{tV2fd%gpY`j_nmb`sR3HT(c;DnX-W#zl zDRsaG%NLWLe_`EV|9b#9mcy@Zicj(u_9{1=7OC7!0vLc_nppMN0x_D)IkhshrX4T# z%17oAcNis=EG+gioEuu~-Tq2}+T?P2+XH~PAk6hOV58@HH}vh5zi>YQoOhrg$nbG6 z%AGt@l0pr*_pf(U5N8P#q~Iag9Vj0>s5?1PWYE}3fX*USn$k@}e}0~C&3FObL$j=| zE*_m&XqH~*5$vhTDR!C$+rM^6?sJIWM|!%k6$cUFKy#ST?B=a3I_g_mbsHE>&#?hJ zZSpJ;&4~(nZw{4A^Mi8rlw^u{J{3oGVdOEsVQp6D}?ot9f)s?6Aq(F0)cnv`4t1Mto4 z*dUoMUKx0feGk2Uk%I^jI%qflAyiUUCc3!U#llz;4l<@vfJ@YBQ@k~iH$>m%Yx#MHXXnrcCkInrt ztN`KQoZ5-&8*U8^7>R>pa%xu8H43)J0T%G%)JWWaEFC=P^~4-jieFToTwh1IH-09_ zgTAKf6VTEs9R|#6z_$gdpu`68@@z%#|uz4$= z^T)sfXu@UsGL=$5?j8)Z7~LA+ynqbtW9-+9?A@;VzFVf0!_ik0(ahe9ZZ~Ahz$zfH zDE8=-q8{D`0`l33#HL&i0Bitv7*zhMu6ZS%3mFQlI_}dqzSgws3ozcR3a&Tb{nf(wqzBNzbTh#;!#X;ageyIE za_UN5R--IUUk=aM2&o6lS4RZu439Iqx=$}TJ6{vuq@^%rJ3vwbJV5+V?q|EmaO0QX z#j45+x>!t8UwAk8C!}h27dK7jK7vVn5RCdO2j$X3h80R@6R>+-U!H-yMdow285e|~ zyZ+vCN*t3tHuenQ0GM6EB8@v8c?1Pt96}nr0I%wLtFp5HWHtcD*&6Twz6Cc<=u1vs zq{W@i&Aps%;OCPkW}oV0MdADWIrqmR5HIw)=1kY*^d$7j-5lMmleMLu_V$m`x3>W2 zBd`}EpJ}rA_jm}`2d4Jc_G`b&YhzNv1~@%^Y(zNPoy4(cKuWsxMl4^ILxYt~5Ar&- zuE&|71CPD@O=$rf$E!sMQn!}#T&GvBWQG0G21NuSV9>CIJJ%Ls z4C&oJM4`LkJ($EY(^Kp(gM(^VfHndPz^ZOx2Rw5Cx`56ZI0*&ctTu#(0V&<(g*0x1 z80o^V^7WaW8fx@ZO_k_%1M_LM^bCG(XI)*Wg$I5LlQxqJo*Smo_&<4-XQ_fa!aUCV zJq09c^tIQt_c&uWO7#!yNO$XRI>%f}^e|LlvQl)LofakmmK3V{Ei@i53D1w&t-e-P zg#_$3{T{hXqH1*Xf^}5YSt)8u8^wCZB@33uy26s+?D`HRXWM>8!$u2CY*Nxdg=mJVCCH#v#9`x>`%N|x*BW#q~xNFydKr6B=`jgSsT0TgQ29rV0)6n-?Rjr zTbuEKJCxgn3X7Xq%Lh&Hxr!WmXHhaxEK^OA0@we5ABl3HOV^Mvy(u`1mX`Fnys9(w zu-3=L9**f1JN>|5A4RLAD96g$Mi&ZoVftp@zhq`h`M5Jv;Z6aP4!}LPvG3Q+o{Wf! z&*bG*6?GD1PO9p}$E?J8#?H?KGV0zrAh8T+QLi9^aLy{Om*^idn+W9*;+Mc`h1hE(&CaPv~u&xS8wK4l=zGRD!xPbEvr%DgEK zMl@8`^Zd{Aj^Y8cGV3Q0F$7EjG<#1EC_rO+K*#LRgK6#g<7~H?_Q6c+RVr%W#Kz9XDTJYvo?`B!? z(>LPzpqI;?2CcgzV_yu4@Pq_d= zx(gt9z$9jM4Qo`8B4utE(MSO?0Gt8n=X%N?-ksbssP>kqo1+Gv>bw*b`oV#P`P+c; z0;*R3){%>!{T#S6qT<#FAhx+sRzIcd& zv@q4D$VvT2>ni>_5H#`-pczm8U+2Z(t0Nf*+2WbL#(IJkbJTx5DL!1|e^Fy?VzMYF zlBBpn?7vTZ)Bw1iCln2iOK;PCk6&DUH@plco2EB9NlHl>PMN#d%6`e$)z=4@5*NcaZypm7_j&C6 zm&gUkS2jF4Q&OfR1x0HK@{|mI*F^&%p@&AES)ae!$n^g70uoAqH}CpPgboV>O+%hr z3VG2T>dcjTy78gJumD=Jan@N^S;Q*hlJe?M1yQv#Q|G)}QJMbJk!<QSvS7uYK`A!%^^O(D1}g5d=~orMU@aPXtbjD-df3?A}41+Lp&9NdxDSH9~x36SauID{WCXx{~^d{oQZ z$3gW|HL66Yt$hkoIk2)HILFezfO&Y}>8j{`5sO5ei6dS?piywwOAQ_&TsX>kLs#&s z3~|(QxF79*`R)65%pus=mb`j&=fLf8(0Ud)_T;yp8-ccn`3B1H?=H*TgwU#Q+K;p! znFc^m?~~#6syP4zO%u?DrbG1`6mQe#oyJb=0VJ_KNm`aYx$ZnPM@m)RL^TR4fteS# z3XyUE=<)18U0{nGly9bMlEQD!X+N-J!lys04c{fncZM8D3r1*!H45e$pGx{bdzPo< zBT{A%*!}~Q0Bp^70u@H}oSxYMv?k`u46m0B<2UP1!bbGRKW^4T2%o*Zav51!6(3Sk z(qW6FhxUN{)PLBBE?nymIvZlgf|RGN=(k-9{0~y*i^GZ8DJ~i_&XO_!0rWBD`TN_q zZ!0H4>{YAD-iRiK(iX!%b)ei>s2~Q4{2I&`oVK;#JV%v7osiT*Wh zO`^<6|DBfvz)Lq67sDJE`2<)r@+GXTkJ}u;6+jMUOz!N*Cq?xc$z1aYn5tB0P}A;@ z|5{rxJZb-$)%u;Lz|Dr>ZHNvuw;$!cc2wry1Q=^!zTIKaMn+MeA)iwPSiL`gDsMWA z{rM0L7;ChkZOAAzzTA^=1T_&e5SOd;Prd)*OAGiLf8pjSkbtkm`_fl`YH~jc2xJCS zLH;1oMSul19dn9GC53R{lM0q1A>|(K!w&u&0_IU%w9f&xgl zepi;>1S7mTsvOd#e4?U_vQo1kL3tvT@Jg|%Ngm_0N$1A zEJ2Ne`nM(d{fPe5gYVy^eb*HXg$^(OLR07e51NWE4t2NTj2S0}6H%Sp`k1iHLI6zo z+EZ2pFq5Dw*hJ|Asu4flUF}W2U`}CmN^f-pU7EWMeIs!|L=k_}Ka11ivh>FTE$?pq z%%6SzK!gq4)P#PxavHISCk>#mappqPevPF~9EIoaA6lZmzPSYr3E?hnV_lF*Va}k=C?ppy4MCXNX-Z@2(*5ErM%wDy0|G*{7HJ@bhI)0 z_=H`r)}in~Nm22%8IqK2$Ub~Ik0?k6%~b(#AyL#AxR=6|ghbJ?LAI@Y3CQpOU^yiP z_+9V*K~<(DIodU-ZrK(8bfexZ)CWc`mFXo>(Of2?d}qJD2f#P+<+&Cp*7zh#TUm$0 z@4)CshfGKoJskCuf59XKLC2-3pkRG&9^maj^+?Ou-CY~%p#m~rE`L+ki6EYv52fhK z(LsPv&bqL+ww^L#1W%dC*4H~hntXVYV%`B$JpwT5BUf(`l8?~UDLOoS@{b>1=aol# z-jdI4nnhqczx-tU;L02`vjp| z1r8_J5r5bL#&r6`vjI<&ns?G|+?R)!cYUF`uMgZds?pN%CO#nn?iBXO7YU|e?B)&?s3#fl)sWpYNw_$#r42cieP+~38N zq#;^hHUu#gJDdRATrW`Cxtgfx_bqR|YO~v792^G;muD|Ow{EKZC7#wsCznlqMqqxWT1& zK72|LMhXB>xFYQ)e^f9pL9fx;8h9}!njSt4&oeyxXsFhy&5nIFjyN|Y&Kam5>g(-Y z18IryZQo*3Q&X?`i#f(lN98LoNl~bf0jK`>g`dYQl>`X80+wGQ&U%2l`wuAAz+en&d(iJrZ&Q$wjX)H^g0iyRCuM`@t;_lanj0gYBB!b7hEQq;@3A-bHVOz$ zgB8wf6hd_~;i&bUkukRwjUcJ(C28$vjk2-G^!x%$K!XCRTDieDOdrk9dO!UgD_am* zbGs;T6IZRN`I9JKoqzr_q~$mo2)#ub`lC9&djZA96$6Q3i;{;#IHE?~2+cuzVfh z2`7E_w;fUg#DY4yea&^YuK~0WlqxiE@KCLM^uV$i&e@VIeFScl(r@ndu!DwZ^p)2X z5Zr@KONJHNNGSNu^+q&mZ#K1PX@}ZgSHYLb4RwW^N4a3Bl1yf|p3XD^C|E{9eSI$l z3oNrrzJBv4dAw2P2FqVEe_k>*F)?s4cOnKVi@U9L zbEbgqcn*rU+@jZ~OL<-;QBhHkPqd#sQ$D%`9BNv$oixAMCguE=7Q?HnD@L*A`>P%wnPPR0#o@wLkq}M7F|UQs)msm@o%SK3xaY` z`s@ZqWzrUX z5-`_{6u_9i9J^_JYp!tQ0RW@dmH7B=t7x#JT(jL<&UL9bu@~UL!}<96mj$Bq#(nd3 z=_e;A2Wxz%Yu2GcFkt-8&6PrTP>hcIZI7p)A5m-_i(Mfq-Q$1R>gf_2&?Y4@n}uZ6 z#F=!zm+J1dRX3O8e7SN=WS8{k<9@Z$S#EDH?who4y*52DD;E`??tem>9P*&sKJg@A z9IJ4p!A-3^nX*QoP_|q+EiPs;GdI5_f+u+g75q{+GO>^I3CJtN)|OIX7%M7Z>lYj? zB7K%cdGSKh_eBWGeQueHvkj}vCeeI$W{ed%`9;n$X$5Rmt(UVt&1=YG|+kf`(8e4Yp^O31XEb^E#*6?ZDUn%q(|Bt z;nT8Fs7}t0|NODElu(X3K6v@^TmwJo{fAf-vsc#QhH8>o4OAF`e}8A09}QP$D=VUg zg%zhoQ%&5_;w?o94X?Bl`zobJW*Y-Plrdm0H$fX1Hr;MSm3-%6VtSN7YdyAij}Cl9 zP*kGo$vHWxJ=fn4Pfmtjoy=1j`d=Nr z-KD3e|J8Id_ch`H_pK{${zZf ztC(~T?Sb8YBiJ54rL(=LCygX8U-i8>@Q(Dzm{m$_XD2t_9YQ+BgL;nEQ%4k0(FjK6 z?Ih+GS&5`Iehv7bcFl#D^`oHS8aa z8=96i9djKW_<~h^0p`T}723Z8Gm%m+lnEj%XGcdhf(as2>Mv_ssPXLMZVo6+HtZ}o zXPT+X8}GDB4-r0EgzuA{Y6wb}6NJ3^`7)gNLR@>sj=_gf>7L}f|AzVaa|7w~8s&?# zPc)M@*vR>lrTGJXeuryJ)5ovO|D0zY<+`|(uldgiSg+D!NIhBFOl&d>MXVMTO*(K> zw@rCs22wr2mSoqz1R?mq)D#wIl%ny^IG|8?t!0%H*EHy{k%2#*f_rhm6c!Vsux~md zI-W3%&TQ*v8d9)A{rpClIGOLF zQsb;|Ajh*VNh^oX=;;*cK9RZQ{OVd&E3+!j5UtH=aq0D<$u{T-AED9yo5WNYUtimE zmyE($1qFYTPoq-nfsZ>5_|c0xGz4ZfD-#RqmoHTr_EtkG>EQk11pYS5Ww^{LJSVR~ z1H+tk*JZLN=7?UQu#o1_BW!I0&zI$f?M^dx{81u*do-_%pOShPg0^*TlMS+2e!coiHNsmfO(ZS}6_*P`GZ zwl9G1)l^>Y@O2&pKyR)#Syw@t-%(W7JhkgxGw1cFdcp)dE>e&M1gGtO_go1=Gj>_ko%-UuwdqdoV9lFE)mWBGIN9iXL`^&^&pN zQS0kl(P%g{{5mGa*wvw@dyxlBo8BbM_VP@o)`vhxQHhIFg6jpq7DBnO@9|d4fjkO&2_6T1{G8s$TeviC zT3Y+yC|Lp*C>~#Mcak~d0A@6%XW8FrM?+Af+wx{NU+vy25EVo?G%$CJ;@9M5Psq&N z=I9r5%C6S+_7v2g%ZYup#zh=jyLd3i-g_}|0_!xMEIYX*LwSN_{}V0pUh zW)+}XCDGW;zdLlfwKZ09fbh{KF1I3_oeQZD&Zffn@K_32RW-Aziun;ru42U?eO_LO z=l%Jw%NtkTD$)D>cm&Oz-;tg^l`t{ceOwg=meTvoSD|UjjOP96xG)P#%QnQ-JOb^4 z{!`$KO7ma4Er(!G9OXtcxH(D$UM@WW!5TZpSSi}nbV*9|f2T#@I9Nee)2X?6 z&Xuef$U3?&GIsDn-oU8>DgPWCl>tQmREZ;aqqig_Usn$*y<$|=Fx~dy8<_1QHmr-; zmhij4Jv~ry8)9Y6dDzlSVPVb9Xop_=_P{G?e0|;6XL8)hXI*{aWd3yvV#WH|Gh`(t zf1PaJSeuc_k&d!+9#5ptAlUDJit9<(fnzR}u5L=Ls%b0`|Pm0WP@lLRCvE z`1fzKi2Iz#x;7PP^5B{cuY6Xtzq2_g($XG1o@F1A>as_ON?p9?!DP3)Hb4;@_sy?| z&-H3;#~fR|Y#ed$SvLG>HAjSpNbBPFsoA@Wix$)b_=mYsfA<3LU(!lDa#j6pgkWCm z>%NKS)~j?Fd{49<*bn`Ab6+q<$W9VP3oV}g)yDv$KMYubcb@3zcuekxysXpJT6QhV zL9?(M<0t$=k{4?ynUv&WRhg9ZfeK@cQ&ZGY?#l~iX6DnquXvo!D~iQBa4g}iauf=W z1te&TR<#*^L+kS{Jp8L&!#3Z{@P8pFlGZ3cF*DO0M-adn2X=maSC(EY%6T`Dqpf<; zE#M~$t;_(ou)X)9R&Zzv?CqMK4(OKucg`)(Qy z35M$qcL@y*l`u$$A7Ba-pxx(>+P_o6?=&lP>zIp+B`q0D-<*{RYmC+{$$HkS8+FjM>7XKHrzhi4O zm{PNLP3Z15a|DsULtTLX_23wja;hA@UK{G{EJ0nv>~)5_zQyD1 z5!G==ZR2~_s(&+B)E@WIWEd1P->E}^xkpoL_eU4}K^n32t{e_0yUh(`BK9$5F>t-t zL%Mh z?djEgMw48Kv~8Hd8wQp5<8ZKqf|E(M?aC@Dcpj3ve4VQ1YYrGwqM30N^8UVKX-VTo z9E9;Q-)r&x4vCi5ES1IXBOAOY8f8rKE%W~c9fMMyb=9@AHRB*QE9WijW=R7xj4kS! zrZJrzx`lwD=C_@W>*o#eZ1OQ(bhQTn1TOJLF(G7DvR)Gq#dm% zGi(^Ji7i!ynl%?>zbc8qyUffk>Cc;{5C@{7TL7InbVoA}tTa0Q1PWSma#Hc}VH8bG z*k>8EJ#4Ly%G;x(65ihBxm}z3J|dKkj!pj2(RoGng+qO^THchti0z{x1VBoC$3q9J7tKgO?r9x!)ptu@mFBBMp z;GL)6wv8W__w|_G8!}9tT*@+@t#ushSGWUnXydRW)5Sei;H#Y#k!4hh$$tIcKH1i` zgw)+#mC^q*S0j%KLshFIs*361y`><@*pJ_j!#{q!&e+|`hWX71goc8{kq)dY?zhy> z{YOR|&SK-t_QHKkb~mhAmr16wV`2ghU8p!Kv9+8v3$!O^Lo?@a! z7`!t%8DWndc;_hS$-;FncYo00IM~{uwIZcyL@>d|f}_itPlYiUScsgH<3ch>!xz7J zeCknTPUv!etL$oYm7f<07q_a+ZNi^~(`*=1((P=)xq;#{zbG9YB6ZRs!yxD7g?y1FmgW8OW!dKjj9E15 zLd?+CtL#{1tnX$2CQeX(X71bIoohKc*q?(EkdR_XwZ?t4WQ>N@2M5*F&dQq5U`IcE zcq!iE#`-?_VU%t=N6d$|?~h&Kh*fKA5JJ>1{uhi;;l$@MY{$pJ9(_wwhN5b>j^!af zV)W-BY#ob|M!ol&CxLk=qpZN#hl{-*%5m;E5)i5lZ>#jr&VgcIOFO+`LTHB!Vn+i7sLH(eez&mg-K7Y3`C{}f- ztCEfhK&?iT#6aopKE$5_C$UtZt1}iS8d^lZn~Tk5>U5vL)IY^0*LDBTnGqJkzkQun+y>BFJGZBGmrgbG;tINa9j$YS6Exw ziH2JcNj6j*uxmG8Vr>AHA@x7v2W}C7ST)m0(_pQ8IGBO@j=g;B{DlWkC zwYDysm@U@zHO%t%6GI?qT!@46rG9$+7pLF#dc9rD(g6b}t4+@oyozS9eH|5SZ14F3 zRS7a{pEtk?Dn8&z-sd9-)*{j=K?NK2XklAT+ka0_T@NY@Zp#tT=rU1NZeoE(;6nJS zr6OjoaqYXvoFBemtHli1u`@cdV)&Q0f>+Y3Zm7bj%o-N{-BRPu*yqBC zyOwI2+4?DLIIn|Hh3eQ1cf=VMkB}cdgT*rTpo1y#{=O*5>1xKcx%tmAhHuZx9?Pom zPst>04P`MA1gx&grW)TN2>u9LUoYM$Ed1mc^I)*P?4{jfl<~y7Bh1h5pd#dSwEmtE z7@~Ik(^2qhWPSZ68aLLWKUoVd>LQaTcPZ_gk$n>Pyy_^&rI4ossV0)cux?Sq!A2Jw zTaq%&q5AwsYP0xP#+nq&-U?IJjCiWUn3(o3!4hd%XYL{%EbNlBg#WgZl_oJ-PFG(RNEFI&DyLageuh0TDS@e>({36=E7oa;BokmTKo z7YoPRC+EKWIxBp*g2BVi&B@vL;P;A*tcd_y)c8ufRI?x)z7n*vz1{jr`Vv%lrZ>SX zyDviH@bCQwMt2TBvaq*>SHn%`$B%zG91=G&GESF%(uKZO5UZBfRP{0pC48wvT3Sk1 zEr8P$ECaAXP5h8G&joo^kl*iRBwO1lThoURYflF@@*e%SH!OUviratg50>>WdJJUP zM&8jSwM;aTufdP5E@K**%{OanM(#iXQVhL`yV3^L=zR#ycKsJ9F9V)8<=attp`1JHfAOa?YQx%)H-*;(S7sJa=0`aVCDF< z|2aPXm9FORb6{<~d1YWiL-_W^3mg(0TCaUgiJRd{1eM4}y$jEbT2a=%dO=+7uC6A| z=l&obDDme>EW_Z-txZIGr>}pVVc0~H$n|n!T<-5l0ERkoW8<2E)>n;SN0=_38H4nB z!!zBYgjm{ok)HdUflnWlv?FpEbl9WGEZ3_*HSZ1yNoKKbh?=7)(rPcOEwGFc@?iZE< zuV%%tvaoGpC*YB?X1w`(GL3vL#5o)t<@{irtDl&*w)Ok#s(SKA={9e@)MbqqpscqY z+geS9QJqtt+(p4k5ZuJ~c>t}x{C$m_|CDh}O4|F*=o%lLz=80uZHuvBXd76)L|O~A zhT?Vq3zHBoZX3jn#DttH55YKQ)+JTY_zR?s@L>_D>nSSuvR3A9SUps6c4A43hbq6X z81b7o`^N6!zm8DM>@sAH#L|2wtlH>H9d{`b+Hy|I7auGm#!t;Hb+TbKXVV#hq^`l5 zlnbf?j7G1$EiIX0Sb*j4UcPFIRWm(nPx0@y2fMgyj2LLkel(yP7;NjTcdZ)j>qZ7~ zbH%u=4JwdyiWB40zP1G$sJv2Sb1gYcUfzQ>Qi|;M^+^KDzG3Ug49>`S<#aw34k;$4 z;+oY1Sr-=$W(_@?<>J5j3<$-93$Z{>ChV4-Js_!Z2NgE5RH9#Wb@}dYFB%5XP|e=_ z@*i>YJ`xfdX|-4KU>Uyde9R4>nu;8g@vM`u?&-Lu5lyOF`@#I=3pbJHC);sGhPP5D zjUqzmmh_{(F77Bj@f8x5zvZ5NfHu(|Trd83gQL5>@PzgUKk&GVs@V-1Vf7b!Gk6?f$RLTJOOF4p8vk?o|;-);B$WgvIxv~ zPt&MuGV67OeLuv}>FyYVF=8c3U^|+hRo0rEwfke1j0%<)PIhy;j0DMB2XL-jKYVy< zuVR9whxR#(fezV-J2e8Q>uw?q+ij31?TOAy=##^7O*@{vOfZ&wNB4w{7AF~8=xhqq z*H_KsRO7J^iCY-qPYT zJQrt|T$5G1tLs!#eeUnqM^ZW)6Z`+R-Q&+CN(~Z3Fqudb9I)xb2&%11A-%1nf}SjFGWee7Uix9NU%zJ)PE!;m zWnric)#M~kzHURj?a0O;2DX&_+2oB9>$5^xEk2fETPhyUY zocb%P-3OtyWI3U$>&mxn6Ja=#be7}n;`eK3Ggj6{;@`_J#CRpwq}398^&2Prb?q`t zCqeGe`(FrX(XojpuK>?bQAtP)pu#cQ*0IG)PbDj$uR*i4WcfK5=I!RLK_%$8`2Ii& z90P))qE-53W&HdGY5|QR1d6OruI@1|%zDT^^=|(0%TAc*sGcuf=PYb&xyevO5_Y*k- zoaN9i$Je&Ge3bPi#-IPO)k9|nOw4yEWoOpo=altstk$;Qbm=6xxK72&bY_kv$1s(t?URu5e($L@Ji=|i#fl?kV9;xwqNM%2O!U+r(jsCpqhyQ0DiDas&ds=AEN=HiNVRURJ$O++s99lWDf&GkaCnvy{ zB=*9Wlp8y6+rsKofKJg5dn!lA)*l}v%*|WuNtZFcR8HbPyH8hAqS#F8t9%=Mehn!D zq#9YKAUBpAzs9NYK6hwo{(FW!S=b+lY^>LrR@Mvu_5`b;@=Lq+2V%u9E{h{x=|}mhcms$9r?qzCGr)kCuNIcf3a9osE}QzNcPOJp#lWhSpa1pq^Qz>sGyW7u6W{@#ECu@o%%cHPiQ`*SGD)2Y>l1Y7rjD zt6d|xxs(sihY=QIu3f;3dmG!}(Wzv7xTyjai1Ga;=}R^o+O)J@q?)Qk(lVxALSmwG zUTF;iB7RnbEpd87!~QsLovAykW$6De` zdWR@GRDyViRYf5-(9!sG|G_AW9>(P)WL8o9zkPSCe1y?{OGxMt?h2A%eqw3~vfDzHEH6I!&gxda9dBk*%PM_= z;&XU+@9Ko0yzIH;l?BIs&QkM*-O_4Un3wdfMlP&j_qI)afrWbToyGkOJs3RZg)|oNVX|$`E!Ebz6b1fti!a3Pb@xMW)4fAdy%hK2u`Rq9nEP3q zFHR6FW$!kjO$$`RK-y@}Kn3<@CbKPvSFmBD2xjCZ3& zo04nv75rQq({1k&+K%vBm?zyp`qw`_UXo>g|B#L&#NqIUsZ8ROSd*(AXl0r zdG9>nh2N6OSJQf?qp6w5A97GPh3as}t4XA+YUnU2X=t67$;EZBuP5KyTaOGo<<{>* zkSJ4t(pq?{KE^|k2L!FPZlaBqz6>zmHz~yy7JB|;$Gdj+8dQDMX?68_i4;vc4zESU z4GT-qsI#kT4u0F(^CP&KnIj0Ky<=GGb#jM7ioPP|GGf9rglKYJ?iuz3mxPa-_jd2q&HT z9)7lmIdz1Z{FquSeN!f5p{e%%ggL2E2zj=V`kl8ygE| zbQq+Ae>*}-KWZIgoG^v0tY7n5S7oTke~R@^)W_B$JUzEwSWaNJGK5>zz9JBjiTpI- z+j3>`9)IQNe~9|ZsH~!GZMr3-TR>@PK^iGhkZ$m$OS(IyQ$)H!!k6yulJ4&A?!L=& zzjMF8Fa~3=_u6yK`P4)f&9|-daonF7ono%58;HUvn>?ATVh%kE8t-ki)n51k5j{~* z={mZS#KV)Pq(Tvu2eX$h(?2|BHKHHU;}r4asG+rovf?~R6}$WM+L{kBr;p&(iot$S zP@@jE|4wEFF2E%{x?C-o1HyQDvtCYi9OjNR<#zuXY3g~wT=H2=ZOJs>_LNjmSkJFg z9#6EV+^97>3hsOxnIIeeBdsigEdPu5m&%_AUZ8QVIia2)zQ}%1w=E+IMB&!!LW58~ zWYRa@-|tN zw?>Azz}^gd`vCUjXx2Y1i+ZK7!e?BL&>Kk)2Er;aJUO}bVo*_0{R7Tx6UmbJt)Kq} zO1UpaGb$)AL6@dLike|(x6?vu6(rW-QgR&X-`u z)g~czmpFiLLE=wHNMB}hxei(CiA3a{mw~DSM7S`kBE}u2h^Q?XCmaXG4@(7cZ{Mt1 zN#Vm}+Ia6u;Ia8~%YAcqS6Pm|mDLR0T~ac!=6O&@n|AK|(?AAj-z$hx%vD080Gf_v zUnqWS2Nt}XaM7V28&QgETKjsB(z>vh0OgxE2igY>5&6)o?BdAz&}OahSf<2}C#Q}TX^z3t2l3OTaOyxKT`BM8Dte;XQdrkWmMt; z3XVsJE{Ge+?hFI`WbUN8(&9o{i*$bAvWqkwMQxSn6|V-|yr?__D{`8PUsPyl<|B&) zZ1uv+88bShys$9hVFniPp=UwI5b{b^7O#o+o?&6GmMLpbM2qoX6Xbj_XR07`lYMi0 zi?N3Gp=&+UIHO_y`F!m3Yv~KnIG^S?rb>O%lZe(f1<#!Ndms{@9ymoz#^1}>C>b%4 z=lO#F^iYa_#L#{PwDYh-WOv_vat89Jy4a0Z`_otQ5OyrYVee}v?G^& zTY$C`el|t7`xt3x`US@20sRyH?zG~j!laB zNU`dk^NDLseBrO=fAyyV4e0o6N=_?EJ(2Vc(L%|f^8OU%{E$qCIl;@*QtW5+@BS~da_@l-2CsO?ZDcauf!r`V6Zr? zorWxQ$|Swkmj;Bkt~_MOCtMit_It{6XK2w8(6Lpp&J&5EM8AHv$la$Qw_X=?gI3jXb=sp+P={*soSH)rx5n#PG43=Q$!-Q_{-<93! zVWEd_$aP?RWc_s9GHlr|zh{Gv=2I~QCoB9l>8H2=3*j`6q~BJvp>a81uOB0dijkK{ zffp@92<>}2N>q-?NoJQ3nl}OXf2?lm| zGt*QY)-KBzn(Ilbsu=gaJz|AL=`1fYv&89_Vpmq<2{&l3-`6b9gcfr+>l%5C^6ByUwf!+BEO{B@5SHwoX;T?6~wO5*3AN^6<*Y#{w9jmGv21H)s*40$jx=T6pl$u66L31-& zDI{od0BVeWcM%!&`!$5@z~ciRLNd*N+meG1(&$VTlrFlav9m%cvIHq|iS0cby-hmf zV}Vx*d{ByMK+{ z{KzC?;}yxt&3Y@(GD34OCgIDM`HH;z%vNp(nq2@!)}?ENFoHFykHYC`vdGd@c0iuj z{8XwOxZ^%KgxLwQ z5T2ZLv_|lZH3?$lAU~1R!wF=q0w;goK;bw&r7GHSrtVn;wq_B%}JWpxa_F^=8n?zYfB4VfmU@0`%XJO&3~OFY#Z2wW}{Rzm15_-!!)!ZGSq z2=Hz74sA{{>6^Td?@wIbm#7pF&7(McH;8*%4KpNw`~FH@0UlJr9R<}~a+Amq*j(8c za`6b6!q7g$d4nj}=SSACWopzQ_!%dy`UXm8GOe|MACm=D5%p{9u5(gkbfSMs@(hv* zP*L&fg4k9Hp{>c*V<;a>!hD1|IDM65^_q1LW=00A-?E#q_Hb@|`)(#lad_x)eu+lCwnlW0O-TI#g$T4) z)uISTe!7BCG|;TtEPJ;4A%5q9kO)(}Ux5*FS{O|u<&F=-ED~zF#}ZCpttbDx(c5ZS z1B*=lnnaNb_=sjX3I<#FU4#`CiT=hy_4`e~t@TvEI%BOtr>JwQa4?Y@^mo2B|NQx& z-iSU5WY9L-sjW@dNLvCwe~4ViRt)J&k4oh=khF2F<|LBok-FGPzSaI;J!p3uj#7uLu^`COl`B z8QlKu``P7MtGl5Zm-JbU^i}}e|AC;(5_(R7M%FB$MfwOZgrF{>;&MMFr3&8cd&$WG zI&zstp6T;H0Uce6NZEbM)4Pjhy8q1TwOrce{_}p3m}yg1JS|s`?#m?*YirBPozbSK zXqq?SX1s%gAST9ky_O2UJ-%CVW!8kjLZ|V4WeGkd)@xdhtBunW!{hr&M!WzkHSkRx z)R~OLZjo-nAia`pP!N$ol-Kz4=z(HDBm9UkklIg+;ahsUCGaMamzHl#&WeY>Rp{o` z$*hU*;{kZ|g4ZJga_w4rA|`YJhi~6*dDFg)Kp*bx92sO1adVp?7MF&nX%?sYT@jN^ zQdG?h6LXJCH@BC7<8LDZUULyPV20F#pm3BPFxrkPD{w46v8nt=QXlT0?m0(ZT2)rV z>3E?wo+5Qw_*Rp^`yAFFAJxLonB}bu%VCR30xAPjlb}Qh{39#3x0#6_b@b-vsvfRI z6p~w7_){^6!pWsqJ^dv{8zC#{-Vfdak=4fGZ6t;{L>^8;XXm>lueeziq~)+ud#!7! z*s{Aqa2dV{@BZGg$om7;rde>NJh__p#fPErdT%rR6$g6EO=C6Ox8@DWy6TWr!EbnH zsvzGw-|(hZTY2FczpO;N*HKDicBSA;m6Y^8s|zK6+;bX7fH`s-L|Ki~_P2yrvj-rh zQ93}Qc(P#MDu%_*DTEgq_Gf3tgi^Pl$fsR&e>w!(clr1E37J`2$|y8Z-&@dW##i*Z z1It9E^c6}Vn3fo%pKw%8s$Owzqna;REwNU13Me8_ zHs>>b&8Be2aM_GqsjK2AJ0Q?f9D803yWZa3@2OC!Qaf3i`KvxzZuCgWq&m_|tuB)y zrE>g%6-XCW39NbUq z6h3+$)wOaVa+-{}n8th&<>Apoxwt4DdHn-HQ=gi3>_aW3KU_8(;~#zus>Ma^_?@B; zDYErJpYfAlB}o3?G3dyWDC~RM$!_&_>c&7@x|(M#N3j0#r4^l(P4;?P$M^Zc>wa|f zD@F>!{P;wtPh#{r_~YMu#fn}X?PO?a(g#@H-aZCccv9-oA3h8)k`ngFK-}DH=on{6RE*+RT+fN5+52IUVF)282h~~^NKoW*yEo*TX>NUun6yF^ zwHq&2LYb)PCEu)FmFnNxc~&H@>2LM;MM4#G)^LA#KJiA8^RsygkWU*AAvi66&AM@F zqmSlyvM{v#_kkY_lp85q45Z6N-|Gg4!8^?cWL3(tR#V*pZ&Wo{D6WJewn#VfVGyg=&Jv?16 zhpQB7zN=hL{t1`jLLJ+zl#6jUz4I>NlhjHHW<_Nno4Q9=f}8Jl7BxXArf(diqqT=9ic2!QDnQbBjq)sVF)Al|TD`2RN$AiD~$0 z9W0zZpxPhzrVTMkeMf~2M}5*W1X?qE4yM9;`XFTkfzrQ_XHP2(eMXO|GqdvAeOnH7;s zTTSeKz+R2UC9O?1m|WcW^EmSr20w(={c&n~KPoH&1hv2V6jaT<62?mZ?SA>0UcQ`@ zm>2_kk8r%+GcOsw%h@#9N4~MCkls9sH95tBZ6F!E;&A4dmTaEr`I?6`E!Sx-=4P1H3mRc;aOovR>sw zh8a28cbkIz0(j6ex~#vjUnj?;=;m3Xk395UnO9wO&2wFE+#OHskH-GpRarHf^5#di zsD?%(TaX@=y%wptNhQ!$T$59Yy9gXO{GO&_r45{RVt2+t`1*ga*@^43r>fEZTL^M_ zFKuf8AsiUr%^7^$QjePr;4{)Al;&Hm%kB|nV1-XSq5=`TbF5V)82t8t7-iopCuOtho`k1x_^bKYsx7 zRUy5^J^xp+l2VAy;%%F(KJ_uN;(>v+re=O$cuumK7XbCr&^yjrXHoq~)OX{kk`6Ez=gU@H5|ml)oY$dvMh z5EY}N9Frl#1Gn)n@ChX&QI7lS`)3CgTitZDXFqXNZ~bg?8j>aTeBXb_{aq^0I&hx9 zxp_D38-iQ6g)izq-EWu$c@pA|1CFB9U<4{R(6{|Bs@!HUN?nb4ev zVDY;WNZ)mr1iEVnIJ^WJ1deMBcDCN2cg}9*xwLIzbe+RGK$q!2n zFF>JjTn-siU_^1Uq`ylRN0X(&phr>co0Jmn;@uzt`Nr1RsGtu4)bG*d{L3EOU?tHP zDc#li&G?Va6kUwXH*mEpa4S*50}<)(!bE)@9!7@D|5jEh5WfX)^<#+-+Des3Mdl|t zECAX%uz#&(Gqe}?5~5>wbFeN;wHAG9hB7`I6sVqNPPe<#8ydpUrTq=FP_NcS;ecsyz>^}f3+e%Wy3@{s~#}iof*SqW~ z#d0%umdO0978-CU?aXrxcA1m8;HW9!*vy#~KFs7Vn)+uzTjO=$u!K+=FI88HuQ*K< ztLkTsADb6PL?V&_8TO7!KkiLNS#%l8TQI+snr=AE&DSk>UntnK@;EXE9P&95|9d{1 zgU16_Igj#ZPay@sOWxvg=Mm+XoK@ zd8D<~N`t#4t0yKDW$s6C(Hxz|l5R#n?oLpAK09}xtPUO1>Eu2+wzO2CH#cn!OFOp z`8}$qfDlT;r!0w-(tX1Uy2l!S9((O=<^A*9w|w4`*Sv-=#S_yUVwLr;Dbe(oG(0 zNM^`+g9FN|3Yy;|0AUGr3<=}M6wih8=ml1W1!CF?O*y1B8sfTzqlB%5mM~8QlR1%V zcWE>7Q3M6KYDdwkJ_**0V9~()Y#7e5V6he5J-M^+U)J;9{q0{ryZEJ)wg0OcO~okU zz$o5~u=?T+KPm7Ft^5!Z6|Tu|-OtHyg7!7)cJFR-Dk`@9gyR}X!F3ptU*@PC7;{7El$kL*`ptj9s(dy8PjYji1bI)$!sWa=LBomre)o0p z3t-L}A`5^BP=p#)YTu^HLNjD4*MR^CyH&Kxyu|2T?yUR$&8fri`#t))rElO4$=GYU zPFl9_>4A@j^j)iJMxk@}tivw3M_C<;S#JDF!8oX+Tl`cr<0pExny+@So0+|5l74zR z$g?G<^HwrEBe8YX`4zKpf3LkYwxSA80LSau>(#q=7xrON%CT^3p=j$zTVM+B zTEtm8)GP@@X{{02D-#QcDq@c;6bed0Um&!x>e1ME?-$jS>bAlC^YqcbeH-BX*e9ca zSG#x=(GBuH^aqpP!T10}6M%3RL(R~{#KCCD_8xAw7A`z*AQ@TPqil!hyYKuL!m0g| zZLeOGAov9S_}J64C-e__S?x1s@3`aI&o(xej_b4wX8=l8O;5y_Y$2*JZ`GjS&t)85 zWm%P!1R$Fm@7o&#fb&)2vKsgH8#wG%j^8{X!bSxRz10+*iKa>XNW=yG9Pby3X3v8n zvHDz*FU38~ozs+>6#S8bor07UUE7(QKT_OAdnk@sN7nffOPGs--w186f_qtDW1J(m zC?aOM0TNs*XfZnR!r2kFqy?$*fumc^Gr}R^Z}m;~Z~sUuP7}C>V=K9MOBExk!M{!S6Fwpe@?(THOHwPk^r;!0rC3j26f9@=i6TQtCm;GO~Hq8e3_*xt~! z?IB9Bf#Z)QVz(qYc{t||5&K9Cys*q1NF zg)nLfh_y!GG#T>Gq6daCF$oDo4o*%nUKJ{of5HGblUuv`>g0DA?@z^7rnGihs1f2L zG5M;Oyc)b#bE0}<7{ZsW8b*e{1izdr%9j2^@#)h7-fibrY-}aG%iV6PrUm9})+oQ~ zrmL*CF^d*q_4THM7pFZQpjbPRe&qxos?DTIYjFdnnWh_WCZGW5{K~x@>xk-1zj5#g zaT9Rf~5XDtvI} zaqO_-x#@8~J{2iiy=z0oqSa$~sV6!cowBe$(mW0M!1Pr9D~$rGNx*_2bOQs-ply$7 zk5}uTn2R|4KH67!$sLA=p9pM$0#pbT>jAUJ&E{4f+GI9uh!zT_J#bYvx~KZ}A&rmK zb*Jp?4t6bPpUnq>^89-)?Mn4L(L6=?Uw$gzcf~>q_cLW5()IuD?yWhk9M&)}j&lx9 zQu7i6(vxppa$|GCGyk&L_-K5t3P^i2L zerT2jcJ2LB@f#atAG7gXz0X0jD)=+PoORO zfBjBoTB5wp@T;qb+inAL%*duyBveKeF>yJDLmJMQWd5M^l!zi{-;;U$*(W%wC_*bKj-c4&P6*Fv{g{`GYp!oFRx9S!1$cTptq>h+tB28# z_HtT^FXvn(fHSq@#ca)T5^2k3oVK$?`6p8#?Ifwyw%7t#(H1MI5E;@}1o6%N(M??;Pcp zHkJJYI=ea25>m;l+J2`|P<+=+?OI<;NXOJrGmQ^}Z5>k#ospJyrz}t-b^gQCzN+hI zd7z$@9Zo*~tQSALbZ8741F4b*o#8zYimI(VwZdbqw4<|bgcTB2(7k@Gn`~MAK~s}t z>Fcpj7M)GYX*a1Y_;17%@CK6Jp&vJ%%hKmEBH#c<#EPe&T}9 zE)I6Ehs{#BcDfwgoHoV}B;cHxp~9}&!A@(#FF3}Zn#CvfV)nQn8VxRpFHjhH+`h5t z!q0!UV)(33$jgjMo)BzgqyK0dod7_6ViTJ-lHDFr6S|W*bB7upCi!z5(*En+y#m)` zyuj{IkP}#D6fMB2(d3<;t%gV9l50^jY;~fH&onk_Iu8@ zXLX#vR=cr!-*FE0kFE%IJF*tqLOiQZBq(H-*u_0PJ?o&(b@FbfeDCZO{}mgXY1ot< zoYo4o-QGQMT2`nqQqt051_m_0q~zKIdH>Zp18}Q=J}^wq3X^ffl=CeF0%BpZd zlvc7@u19qkfwXi%UXb>c+XGIBY=8e{4=)*BhmM0nuwy5+RTRb3U0B$__0s&w+a_@) znAh3lxVhbJu3KgTHk=&H3HdK>@2v^i1n&!*N8DcZ_BymS-01hd#zc$?sutB;!^n&I zgleXx&!nkos{e4iJ)rjpvKsE!<<}e(U3i?BNo5b4`Ag4-Uee%D{|G?$1w-jn5hn$| zmjD>@Td9Kn-my&7E-H6I9P#A=LF|=mIfH4}_v?q;mtd>r`$*}D<7V`O?drMEvY_n9 z&>`915Rk$o2kg`^6@xgicahqj?`--Q!tVpf9UTj$CiK_DHFRfv-$)ZBgZ*9h>rwCF zK+EmrC3>R1Op<+D?_QS0pk+UU@+%u=vXOqlgL55O@iq0%=v-(?x<+I{vEt)VNt2B( zVt4k7KYxdeL-$KN3e$73i9lH{El|KoHM)i4U%ym*rKDn{jlUwMFmqQ@DjynxEU%Q! zN=VPVLBg#I8nW_r+{)+Eo)fgWh~Thn^BD^Fld{XHDGH{qU-9b99Y4YO;L!NM9STIg z5{It_AyTJ zH#s@;gZB>AdYOjCLM?@t%g*+j1cNrXZ{G``;XOw+l$T(ab7p!xc6UA_$dULu2c(9f z^DTF1wP&AIC6L>>=TBM%_wsj?2BC~6=fh3Kz(Kd=%`KEh+~Rs}TEynFW$fu(h>FWR z^@E3-BQ$d|%IZ~OBHl@mktB=9&6UB@T(1Wrnzf!vg++{agFRARZWNY0Pt?w zfy&km*Vf%ZUh^|u^>+F-sT3rn%#>v1$Ui|HqKqkw!N6}3iHeKQ(2P(^<$kG>_RAO% z9%dR&4T75D>EyuZ>-WKgu8Tx-x}Z~B_ssCmOYV@K4x{w`t`hj?VyFibe$Msi^|I$P z1!;fB+@`+RZ`S6Fll^#|8$PGkw1I(>?nk{n)$^hK4cOfvVJ2S3ibb7>u&3C75JKmJeb{ah)B zL5yg0u5a^sT#htK@aTQ+Tbi7;^LwpRu#>=1~_K8XBTw zV*`qdSzuZhotGoRSnBhai7McnVgBX5c-0_r{+F1bx}%G@n;zv31y;5Bh3w z5=45qO1@2(255Die;gVE1B|*)6Ho(T(DKC7?#8X3 zvb|SUGARDJw5ogS<<*R$^F17TCeQ!uv97*Y)&qwn%-r3&8Vuzi_ByKTj;z+QL~Oh@ z{&C&~%9%%f{S3)Yn!AIRwp*qy18pY!CuL6xr}yN#_jsl`xnl<^l^vcp2b|FFUN>zI z!{Njo7!wfp04qqei~&s;f7RasJgQb0K7Q9aYwK;JRyutw$;dz1-}~2eyjI2J&JCS^ z#w6Cv*~@JeJzcWaU83r>UoXQ0wDVmmj+RARm&tEu!wOF5XWx0=Z6fDY_?=hR2NlYA zK%e!ez`(N~EQ6Rv*xW2*+WnJvcI@ZP$43-j_vmye8}ao1LViW~+4r$42-+t)9*Oxp z3=rvkf9ABnD5HL#*^0rg=kYOm|8&leLKWCqP%iz&m3R;=a*~eh8zqbc)7cuqpdSAI zrtTFT-8m=UrSfgK|BK41)5=Ty{LL(+?9#GBI}n+3O}#SGK`u`l9zR5)_cz%ZE-%%% zF&D%gMUr!NC%L`=YqTta8X&@^p%coqN?A}eT^pAs?L9}QJ8wvZE$D!D*LL#~g?Z)~ z1jvZl;Q(~AB_moV%+oi^fJT0{F~=g#P>l;xpLg?S?3*5S?d&-A_V%!aSH2Mkw?6v7 zW440qD`epL91+7>1qlQgTMhxQfYR&3OhV04mU~|G4TDfxF8X#V-5PGg`IOcK=Jdo) zR9F~1g~yL%jSwSL(i1ncx`{ccU~Xdyrq%O(`t5RZOh@%>UJ7+G&0FPv((n3Gug9v} z^!|PW-Ma*X(t735!oa8~8xja(XX;4@h*RK9<-ybL5YL<6SoKSS??|Rvfdd}4)#p0Qn zg)jFBWn)3n8Xvi*5sew6JyYz^(6N5=G1&C=U%ut|7`cJSiFWE%=V1YLqnT~ zUb=agCIyAeMa_{_UBa9nl_|Iwr(oUZ@wVsEK)c6rlP_JGE}0q%1F&09PI{#QXbz0{ zY|XnSzdKe$+06;Sw5BJINb@f_#OFH}($ihR^L3bfB-};!N69Gtd^54dmW~fKXmyD} z^-IYX~0p&>^9?SBAsg_XlWS^Pl9TA_cP(|OvVNid{#qpre)E4{g&>;ckd4H zfTR-WZ~eXOczI=lq0py}{mJPs2w{s(1~_w>L4mnS=JuR1ftnoJc`=lM4k7qi*r0@^ zd)=9(xb6J`mtwkng--ss71qvE2ai zx?hraTaJ@#^;yk^T_25dZ%;k^{gcCFMGPWMjvi}#{{0}15#W=!{Uv> zJVrytClflG!zzJ<0ZoSE23DJSOPepV7$83@sfk7~mD-t?3u)yPW>~Q2+Uu|zQ_~AX zJoMi&57o`gq8j3@%iM*h}+sC@WEp%D>TfkcH`dNmR$=EfqLU;2j;W12Jyym zrje2`5eLVPw&UKPR^w#E<7+tW?IK9gqlbrp#L-Ji>?{m$(2i@@F$a=)utKv|cCw?o z(ODZyM-zbV>R%=p#B~!N+>~0@P5ALTUasJ##PI$97U0Fjh~vi@!qC>Q!Q22dU614> zOs~Jux6+nSB1!{^dDG33h@kw+Zckm-2vd>RHZXji=!^Un%Z`58L%HRpW5N8jqqtdf zg5*0;hQ#*0o3^np6vNUlMNwLn?S)}ULML<4Z4r_7YR)w~I$3q%{GqI7V%3-hgNW!6 z++{5SCLMeHs;ay7>RBW}Mw3!7iORbi@j6-V9!*g?pLQM0tvevyz=8YH0(9A-c!IE^ zI@Pm*$YaF~RyV57JPpbFAq$)wJ4kPWf+_3k)nna2Now-<1j3gtB+yu)lj4sM{vx>ZO(&4&7YI{`II4mvg z@8=zZp+@tCnATe!wvx_y^)1wP#c6 z$A}gVLmj=HX3&-uoj#jrQeMkaD5kf#ctB?01dGo0UP)bw-@W$}W?}@%^{-+if=2kp zYYKUtAb|;8Jef|KN+Q7|%$)|{0<6M^_fhR)R*pSXQ7!&$yO@`LhV%C{x9egTgNVXj z=7g_$YGQ|U*Fs%c>ZfEdg#|!8j+^h63pO1ua=ZT>P1>j1pu=vig4ffW`UqO#M`b~8#$Ss59m{bz ze7CppD-pHvhB^jQ^w;XCyzQ3U!qF)VYg1=H7nh?SS7@9P_w zWc;Q(3zfKO8JHnfpas6|qOV`e2N})ZNW1f+(+{ZD^mL7OG0@Qb9uGxOj>ROk-~L7? z?2+Qe*z@0Yg@lIgy{SvAEXC#4V9 zHzb>nr%@d0L??b?hmtXpR93R#x(*9A29YSpi>Ot9$3%Nvpbm({q{!EtuKfL)V!!&U zc4E)^F6%d}SZV&&<;QtzE`z(9^%WvgBO~@gC=;XwP|LRC>(kIj@c z(FW4KY~#{YFA}&sI@$_`!13{^KLhjq-TKd;>U6f9I3q2_@YHr#_FlIEdfM5!(fr2) z{o+=|@6ORk1O=5B##+!)Xr{^H@y{N`Zem>GG0ULZUJ*$Ik>F#D)aex}D!tEw*b zp+RoKs>a`MT6(-yPDt<7MM23xjqVu;QIa@PgAk`o$(T>?A#+recM>ZFGlC=O4fc21 zw4>6ADBxK%T~2u|Hp1i7Zf|dAS635&LJ9(FdqAG+%Yj`qF%hx_L_Grn<_!CW=;Z6C zd!+>yN$+SecmBc3M=qA#pez`kg@3wM@tt=FoGwiZ3U|^D#gIYxwd0n-$70VbSgVEz zVrHrvFyvtgh~za29iHz+2PooM3kb2J_91Q?jKu~~@lI~hRYJ!gjalv5l9;-!4ioeW zhUOq-V;=+t|I<|j$Yt*Sl~0!Z-R_5G4R<=V{) zE*21q)Gm`@Zj1+KM|SptX-h8thG`>>k&IjnUi+b2djhO9Jl$fZe zHL!bHTA*b>v;Rhv;agNl=ISI}x=oXwvZ=MW&WC$dEd>~%Us}?395Eo+Pi*-a%2@NI zxp9(Eho}c~A&;k9(&SSyjD-1K#41xXcxNZ$$Kk9=L=T0xz%h-YDOuXDSlh4HyLor( zK=kK+oFm<$?cy)gc#er^J2}~H0J_hqm7Dc9%@+7A4{#}Vp>^HK;B?`umF{kp5^?iz z?>R%scw~>>sg6%}iPq4iu~9T^rxpIho_3PfsF8iXGte)A=IXr80?G8Y9buHB0 z8xN5SX71~wH+(wed9;1=rd7-O1%2SlXm@cXt$ux^Y_|lEp;NPr#63R%1`5=gy)eD0G-OI=nqYcn37;&k7YkJO&xCMIeJ-5?yUZm}KN!7h6b zx31EqmxiT5{KUf&i0bvVJugS544|L4BZb_)M*y!5mG3KY*nh*u^`i5PUK6~8wl>+` z{(f{y%7S&chVMP7g`q{&bKg2@LF%<$xcdG~QYOU@KkVXs#>*dS5VOWWPz#f|KA-TO z$*UysKwL7*aIRsI*;*LNHc&pApRYM7;or{~bYoh~8D}DP*>+++Ex0N`qN+FHb?Fw7|uP8#+rHHVs`e4$aOM9ugSS&Um;^%uBP1LPbq# zHVn~z>l-A(hevFV9b8V&`kRhswLLzikZlzLMRcxTw&W?r)MQtX7r*2A`_xAN%`K!7 zr*fd3J^dKED13_myfkf_MKEZ0*7YHmop${Ae%(p$EKW^-+w}g;SUEiDC`yRM{wzQN z`DNWW>T-Ze#};g=BJJE(&BenRC(tV0$7*Xkp`mTpyVCF*<$GQpa_zm9TP)G8IxInz z@HJT&(%X*BwRZXb1yOF_DG*%f{=nL@6D9p=71rr)xBOLALN0BtO(i|^?EGx8_>tgVjIuwWF0*%6_R(|_4`!YZklp$`{FgKybL zc-X`fR)r;ClK|xu6Ia5Wrx(8bb;>sY1j7!zV0Y{ZwL?^pthk#ccTc2ImOM5!8E6#+ zDX_{bDn{#XuP3Qv0|qX?(3j~Q54x*0ip#r4#Ip%^>D!Kqv+L!qIp zl50-`>wRmID{2Q&Guy43O;}kxxU3BF_Kdio=x& zSbl#xZdG!B#eX2OT8_8;krnzGcPNZyj1Yw{b%HnD^U7yIRT}-67@R|9&=P)mjDVR`GQq3K@nC=?L+az*UC}cbUW7V8!tODW>n{WKk;z7iRZL%fO z!*z?^e3|G7(0ZE{E$;N-m#`*V4-M|4F5Jy`Lf|e)GNe~iy9}wzbEO<41Fp#8) zZpdPjr3T~6=4p?w{SZ6LNXr&U67Aep_2H$Rx0VWiLW77MhkY0TBa^i%&+d-}q?Wwg zv-326gyIun;XhgH4&ekOIPA$v32ds@e--CzdF%%6JXZM|3Y3r#0W;PX51Ul2uPnN~ zFD*O7g1%ebmec<4NrVL)WMl_e4UPcw_wV0UO790>1y7bxV}v8?=381!{sT7peP;|c zZCgaEy3M%%B&GtwA}b;kZSRZM-6!vbUkrF0(jJU%`9(P}WBHu6iZ7?fKT=u_HX@*F zROEVd%pc}jKCee5&p#YD^A~x)8RfN@n1VA`t@GVZho|twu(`Gp!p~3e>yi>zd#0T8 za#!UH_%8B6Wp@Jtu@ZU}`?Fp5BVPT$AI6xU=Uc?+Gef*VU$=AmvtVGJ?KH){eV>|iaS9`ziq@<8B3D>{-`_ZV>q9rI8dKEec0*P3@MTM=O z^<9r}mIF4~x)BEi>b2^ahrOl$CcKrLnd3>y3GCC|W2? zy2qIId4TUhGk+DsSina>8|J)O4j?2sE|cX$b=knNEe%s1;JY$59#gS8ZhD&-r;Alz zztjFSBGzq?Dm$eCag6OGIslST>|>+&-RW<4?{{9U?B)eEHjU@ilc@i%Lx1BJib){| z;n6?4+mAs19VL{Ms;#KVoR~Bc1})c>CgD}#MnD{0oxG;pkXs{O))xa1~% zCafo;Mrbpo(fw8Z<;z+g03*k=sEZ%r46EtD29X6? zJ+C9hbiZSmaU*VVKfET>Bv0*{4IJp)&EiYb#uX5=0|BujuVbo*M% z8bS0knt>pp4%v;Z<*(l%5fT@kM52{?(!TdU-$XiC{w zHOaj}{Ks4r?yCW0gf^uzrF8iCB1T5XE#~H~Y(!Q02rgyda?ykh8MBxH%rnhaVAIy# zWM%KeJ=iS#kLn@$uy^60`H{jd_+1P+qZLn-Mz*P@j-5Sm%2*X?2pO=UDapb@JXO54 zJp=~hOoposHARWaEQlL!h|KhzXAxc2ca05sLTUwpfg>aMaM3xUhkyVsN|0cpTF%mv zt9J@_EjOo(n~5yx2L^v?DsU&1gN5LWWRzGy&dH>{;W3$;{k;#a=$ezt_rsGOpNL9q z`4ksZlIN+9U#mjhjGn8C*%<8txt zV!y{HCFZy2(ncur=7A=CABtX9G8@@TE*ZrW&!NectnYnKTBg4`}WaiUnW7ft6 zJZ@Y77o%d#*gr5F&7aaQ%$L%{&;*DM;R>ZkhA<0lpu`D)X!m{f^ba*Na>3pcRNTM} z%HsTtzhJbw>@hNeEol^O%fwbK)Iuh6%P)gn%2y~fKyi^XliUz84tH31VbIr?Pj&m~ z{AfF#JDTCX@Se%|9avld8HPj6?d-8%#5t(;gaa!>fHqb}ISHdxg^F@>{A#O>+kQ(D z(GeB3&^P?2vb8rb;67|6n#?4&GJ~{B)#eqyRs`KIU+%to#{9g|ladh$mbYL4f)qe< zpa8B`7*E0%3Js2k==ygp(?kip)X>nF0jmvoeJ|mztIVg@z=A`{G>@}S4`6ma`63N~ zM6i*ecH^hCDEpWH0Exi_5Rd3?Ps#n;f)eAGnp0GxgQV8-@*`8Z|3lMRMpd~+TbOQ; z?hsJAyAhO-6zT5n?gl|pM7l$|yE~=3HZ342NcVj?_ujt_$2bT4_WstIYtCni+U;c! zjWEzvfv2a4@K56T<8>QhvZW{3#N~Wq$jNHG;x2A|3@KIEiUe<@qJdS51uyy5O<$vVQs}qO=F>}J{fm@$jH4+Yv^S4aeF- zUMs5)X5+kLzrazPWSI=Fdz#*aD(EZ!(8FIii7_2++hCYj+Qe7n zj7E=+&NR)oV#mfFcW{D)d))pkq8&y&R|syIuu;v;YNIkp<`BD$Y1v{!a%lu&rJ%V_ z*;Mpc;Ao29c}Yzhw&nJM4uMTi(z7ayVrDS%zkj?!-T$GbMd!2-3De)N^xkGbRSPN} zg?DWzh=*GH@5lIn1$~0hGI9`(h~XDgBC^v>BlUR~Zr z2G!Ei;&8QO{z9ZA={xq#Sn|Ed2vS_cfTGRv;UM?DQ0n_&DjIbPEW+Y%W~O__gZ{SV ziQ4rc(R?gaY&6poznPpCfBfhFTq?@Klc=>_L$gpT;unU99@aP!QeG5UUn99~NtkB%QdGMVw6 z@LBKT*%dKp*B>mU#*mTBvLNcQURy>-`z*cdUxfYobsw+()t@_SltvQJny|5K9i5c? z;={gN(6bg5&R-b0ZfKZ)cpePH+tn9+?7KeheKqzh=f-n=I7q>I?+T4uo8iktHh1w7 zKwb0hEo@D~B(}2F{Ce>s$$b7?E-nEqlCfl$V>?fY9jUrQl6I9rPFt%$^1Nt z-X+=Y4d6~MU~oGcSGNe__2rFyke)A1I=JPcPfbsNL|G8MJBqv&nTFL&OUs!|YfIFd z=)PvyR8_C)4@u|mqK<{*M_*VQuK+B~UH^eigK9NDKa1s42|?frYx8W&PBtB3rnkxB zw$2MkSQvSmr*|BbpEVCeqM%xBJ9fLdO=|uWjQhO|b03i+24^HMiZ5lGp-6r6Fzytf zjEdN_P;=y`460nt<)g(=yZW@hrOEjFzTyWVIjzQOz9bH7Wk~Yh}LzEpvX=9ZwO9V ziaG@d0@+MC7pmb7DAm?5rK#P_EXzn`fCLt~_q?XckmNfhjma|)4{}R>3IWot-^1^% zIKfGAbZxe;Qu3aI+Q_J>?)vL8Vr$*=J}tR;=d+z%o8qG17&q5$9T*#D-FUd*)TA*f zCJ1HK)c!Qc>-)<$a&d0Gr{FaI$06coW3l^Yku(Xl=?_(l%Rcb^u@`1qfu-zz+l`aX zV?lSoxUwne<3F}lZB(06hnvk=)O{tDzSJ+m*LC3Y{O5L$qGIOhR>~j9WWBxS>FnXI zF-osFse_HAC|!Oe)(8$(b{@pa%A4*4(f=nTzeaDWB)NQ;@P# zAq}eLPfkG#U0^bPyChw>ueqGZ9kg#qdEx_1FMH-%IEl?%6SfojAOqzd@r{#h&@kHD z6N>s@9oq47eNkm)*vO8!f&#|B^K*9N0koHLqeb_1-_0M{x*8yTMTzZst*bUlYNW-I3{$Y?7}z7a}b(QJ|beaVajfxiE1FHaFe zzn|8E*J?}$`K!_``jZneN9+>b?v3&^?^RIa*|v*+9wL)mXE9S1-7zNfrKoNr(&i6yx4il)J9fU zU2NG~%49zYzEera@MLM~S{!pfEcYZG@^Ub4X(l%bv)WfQB_rmvS@ri%9+$=*VRpq z%BnUicHUWSgi(x6?0+FCa>ghmRx=D&QH2Jmf?r6&|H+rxckeI}{w-VU@DkTIE;=g? zU^+RKr6gf;fq;3zxYn{Uh4&FOC=$A}3l#q_H6>>Ioyhp_c8u|+&O7471jgp3OYm!f zO{sZ@Oh)0;^{S#;$sbZ@sq+f>Xu*@*S;S!c+G~7>M4<5tc4HcuAqdd_C;DBlMlpvd z*$89bo=NSZMn%k-jcyc^PZMg%qlcb&@ny*AIul7&Y_gAjM%U340Ja1rUER zS*NGEf1#JVhT!w_L-u6MYbHOb4e-4C+iq_6P-lrIL*|4OzewZIOz1SXk_Vu1#0ZAM z%*%QgSw*-}uq0-Y(_h|#TG6qCB-C4ki zzlO4!C?Vla?ALc}9F_)D0*-1W?NZT-Dol?ZJcGgvn9RK@fR!TCR!#6MoymV=hS-z+ z>mflMY^?0_1V{A*m+)IwOlT>f>8}ipj0~h`VY2)?&b~3=X2U?Fq6xdlVcuKmvxFct zreUOALyU#ou55tK$Z+MC;lQz(W73o>D{oSg)6yYaS7qnthbF6pr=~I{mW%79!Bo#s z9I#3ys)C?x2yzRenc}NU8hQBv=FG7ThflMaDZ@HvpC*u1O<^8_P^02^p!ENSQ`6b3 zo5bg|H;|orc`}xj&Hklh|8``9vikn#!e><=)X}@}9u{==;~yQ>?j+`<#2Zk9c`Y#g zm&~Ih2#q%eF0` zV+4TiYWgek=!lH0<4o?JKCBN}8g4IBa-4t1!P(r1mozxJ;dV~tG{!xEDjAS9nBiX2 z+Vs)TTi<6Iq5UMn3Hj{3F}1_}F>phtqMF1|C{mNQ$1shJ$xT|sB@a=3Tw+7P3i!WN zKjmjI=Un~ne4e97N|lLQ@w?aLV5Wotg@)sT6MXwQbaEcx7?OR(AWrw^WEaC>i9?cD z2CM_-CRKR*Vu+e-{FInl+PCahSf2t~bAyH>SvzMb_FSB(ea`wf3khAC|Ll@WV={5Z z%e*1McWct&8gG8~+pa#}ohs5dLhkuiTyFYv#j8zkpe6HY`)FPrazf3H1%eYTO-MXB zB@qlBn(wAxfh1e&0b65 zh2P%l=wIZtrrG-%=QXE)0~DcH|EwZmjXgkt>$f+PPbp9=EZxgaZ?=gUd{5m1@M*ub z^o@*?ZBR|Sa~4Kogw^$mJJnA?JaPE(3(1FG+_)P7mvsM*YO?cT+Vjl6jgLvM(Xxw? zUjj-Q?iYh^-<(QIM?U3y&ZNls)d{?(}T z`=t#1o)8704|u=3VaN@?^J0PoW4LAAr;mz=1JUu;&6rpJPwAox#A75>zS*OAbOgqp zQiESg?=jIp8g)Q0ny2{w?<=8e()wx8yEoI@p!Bz03O+b)W?)`>hP)-eFZC9=0930v zeU#1n_M>m>Pe7lX9k0Wxs|~DCUpFGB3|qEnd?`%J)xt z<3;s(OA8Cab8?a>J>RA*Y44|`+RA^lpeP~R4o;L-?((Ij%S?^%u1_i~4fVT1_?EfA z+Z>#tF;#acEoTGX(0`?JpE`sOD4AY*j$n*RX!Smp@E%Mjwcf>NDbp#|4$O(6m-H6r zNloJ)wa~OfD69qRVj@1ox_n^-?j}J!Ra^XLK2#&52cthu?|H+m)~u*u-lsMj05pWe zHQz6-j+s8%HWD4CLfhSv`~E1b!=wbR`8PgymXD6?>~)KR_ckAePy#nE{~7tOx(?WN znPJd+Mk6DB+8Q@q*46q{g?U?ydYichqItw-wru;(Zc;bENP^8`aze^XzB{Key zHE&qf4!(EqSLXVgT;IPpU`_olZs<+uVuqouk`Q`Epg-CbkM;H~DMcSkHaa?2$5dWX zIK8eR6#1*x3!p&rhb08TsPX-+4tw5<)*6$BF2#iY|7WNtBUS_^Mr3)h+hLvwfl9)J z2`-+(-(;h2sLJq213{r-u?PGxunw)Dd(Z5?GD(kvyfP&Y^9zZpX{eWV>GNKOLIWcC zh1B($cNa1(VJp?5&W(k%F4-!@D4idaR$3Gxw266`n;wGC9sS>1$)Is$9E zL^z7?r;^5j+)Tz(bd6G;q+?F!7|;ADBk8G^rpEG8^QJcWD`&*=@^{{0L056{8}g*7 zrfza*iZfAY5zFs$rIE5zm&DdR#(l1=wl6gL9&}l2m|N5m7^7M2+V2l?^!v|(`Ay54% zI8>;34x=dQ5cZe)y8MupeHS~AC}M7uNPK4E*}wFRj4P+!Mn*p*o~cqR=@d}2JxQGk;s2KSTJCvcfh9`XA3(HYsF60oW3yfQflH6WQF>XcST)5x5V zFyP%!>FaWTJlNngQ+ODw-HiR>ElM#5#>rl31&q0Mc=+9*Lt$a?8Yw?tSr!**5AyV*OrIMGO1og zhvINPhNcoWJU}U$^%b*SwwcvkP0ei0P!kHoS9EZW+G?Mg>a8uGFHd`GCa*Ugptc9P zcN}v&G6&accH~a#>!8RRBW_$7p&N(ATSfW?rlHKYJ{Zi%H(vojTD01R|MRvrAg#ud zk6AyE*e|{|6hZ47_$QpqGp55H4I*U!rhj%jo-PxQk?k;xH+Jh@)_U6#5Eirq&03GP$3y+QZ7@L%0{jbDXvN~k6*ltYqZ$#atHF}b zmdLnu^+!@EfOFiyW2tCr4~%%fpY9G1JE!Ig)`e~QkgytGZVV`s3W8%A5Wgi;l|g_* z#=jXYuiwIt=-I;3&bKu()?5aLMIa;ir5E<~=h*#Lc9>w>* zygb7OHK4JFC%a#obH$D14S$7W*<1i4_1*S-x!dND?Z|2O>N6aTouUlPK&<&(Z1~Fi zkp+F&G@F8UEZjky%0XS#wKuP=ja2Zs4yS|D+CJ~R6(n}W#lYTH!`i8%pC6Y#is8V! z&IB9|lW}Py3NT5!1)>$LX^wOJ&ZG4W1VI4{Bj~>Hz~zw ztKpw+hLuI3*Uq16Y98qr)~$oAK*ndjwVE%{V7ZM~43K4=qX3nL>CPCnYGzvLl5{1% zk{?@KyF?kc&J_1FW@pRR@6nL37*5FhDz!}+lt?HhWRHIjjknr}hs5;I$|V zcY@luJ48&@!Eo`+i{5U*n#W3(^DtfkrsM9H2LGe~vy@}HQo0hGgfnMrArOh4zBAB# zA=A$E9Qe|2MJ@Ts#IkO(sLX_IsmMU8>aB=kee20GAA}T@K++JMr+Zy`zoK_ez4Yd~ zGrAR(l0EJ|mR>nu-lhl`!_(}H4BO&Ny<|{eKd$>qvHOG%kK|2-kef|wD@Ep3IUjEI zkDil&DwhWxeed$;Yhxn~i`;}{B~{|xk8x?3Kk2NHer#ie!OCR8|0pSumXYbPu5AC} zd%e1F@$!ZEe)taC?Y}0JAYoO?A+-9R0k1X2K-*v*AI2pOY9+3^p$>C_T9lga z82nyQ#5)U{-3z7`YeL&A6Wj|>3;GmpUI(X}{REo27Al%eb82m0Vu_5$+QdHqTx5^r zrBp;uFE8&xs;2~+eaCR9pKRn)Q?YV0eX`KfcT03$JKl9*#}+~O0&RRyilv^HA@6AZ zyGym{tQp)eetLpZwSvTvB;~A|5!M0YMqpk%Vh25Z;-ZxfeTSwTV`Uz~>~UK+pZwNJ zWSD1~_nh=3j~XfZF`e4$_>Yg71pIDIA04Z!RhrWMTIke5C$md%xq-`QfVVG@6nrOt z5-Xl27zK>}i#oOgI6-5CMugB%um&K#SHS~E;*;A;g-h(Ro~w8gN3e_)1=4F2#@~Nw zYWg{2shYZvs+LBbn~PIm@P{y) z@vf@)Lvkf-qy#6Y-Ub0bB%cSUfsPezQn0o-^%rWcJ>OJVQ0N-qnxibJ#)m@1_Z>4W zP%s7bILB6i+Ntix2mcqpO@IUf-Ek|~ckIPS`hZp_$G(uz42m0S`WAh>=>QY-D3XAa z!W1OL&p3JFCvd-fH678gHF{&m%8+XfQrO|(2O^7r(ea>!U6d>zU-v`=&`4)I)t+wv zJ6Bp+aMEY7?mDkI%LD%6BuI&F?9V9H$0jh%QsYEx)WGpQ@fmCm!Xn@jL^cU)G_BS- zuG#;yZL5cZhJyO|K}8wGO8$8ADEA`M9P7Lyd-`#-s?hkn(VSOryKDHnWtzr)Ylwf1*8>>GJ)l3G9GF)PcZ6_qUpy22|Z&UgFj~pCQ`c?(7WcmijcINcN^x zRrhEr1^iGksH?$Gi?QwfJ#2$!d`Z6q8TCr$caE9}V{S0WeMooia~Wjn*h-6|j&9V| zV@*o<`SY%PH%vwn!TFoMpJh5ySsC2bVz7keXIvA`r+a+?L_+3Vx8<)?TgMHx;Cl*W zK81E0R)HRGNuQt|D@6761XD>H^$5V!MwsumeYAtaDDcOs4Kg#_5kR&2qVvSldaM+I zWS+Xj?EE-Qo;##l%jWm*@OR7_Dr)~=n~r&2*5aeBe-GznYIrv9P2Y}9)JrSy=vA&D z=r?8;X3ck|G_5j)3+@u0rybA%e~}%IBNDD>`u;g@nh~CP^;a#9*}j!nZ8RxkpKiIo#chyXptS~i*5z#gEFsdI@qtQ< z?Q(Xwh+rBS)@6Z`_Q-Leji9Tv92~g^ltxw8jn~71K3BW<)zaGEo!tY1miv|>RB_y# zBCAtY!I(=T1PP@ouS=^okO52PwI|1wSbFW&xfQ|a5GnSisH_a_?c28`eo0bP&kg1; zmG6|ZE^eRyn9a&jvBw4eF^&QIc#uIz2?x88G+W=&;aWWH!@MEF@UX-khUVr!j50{w~bR5u6OmSv~^`s()_ih<-;cg!{!z* zZg7^tjoAl7sdtAGW!!7HK2U~RI|ynK_*yBX>19=CFELSQ&{-%emJJUz^x4h>F%ZW22q&*RKI^#p3xmEU@GS zQHxa(XT95+k^;7LZzfdMXsvh11;A)BKrmlEL&59x=Fk+>0|3P!E^M%udketm^(rF( zN#)Irx7c|2=VOOp$-$m=nYWREu#*)&@$|*-jrXT1drjS>n zP+{a&5K5Bi9>A)q>;}SXB79sz?DBIl#7R> zqqvY}?3dAIvJMX#9cv-UFW|?I72bc-a3}Y1Gp*AI9`*p_+)N>7@|ZR~;N6>u1d)m* zk2cTrL@3Pi6KK=>ix78DUzi>QekEuT19*yXC!1kF-W3FrfnYZY^6Eeo^qLncxZN_E zy+wKd~^5t}2>IZr~w!W$7YZP#&L(q^nqg?aPDkq3`DUPS*JP|dGxGhEs zVk!C67Z}GVv)$}Ta!SMdc0=y_nYNg_YiV1 zXIC!#kv?i9o7TU3JjUAjiC2Ox~3YeXOb4nwtuM_dtu7dY70qZuu5SEDD zR$8Z3PH^V?kG}p4_|*g<@)ip{?{ddAKGs-x>H8y`f0h#HuCBPXgzeWDh}*(BCzFLG zxbK0Yd*;-b4dt;3Z*aZ(9#k9!A6U_3jMbs|KRBupq4YSMZ$)-l77}U4D5UgIjTS4H zr>KX3By4}@skrfTtxuZ{$*sY!;ROyKh5*mt`YjFa8LSg*-mk2!RVD z5kZF)oNILe3XLxP`%NPmNXp%Egaxy2h}{$}hLtc3pn~DRUq=Rom)c2bG2Fh>lz5;> z!Jr53#h7h518%`X0E}bKp-cp{ifR)pD-eB8&M%GJ^M4|xnydpg-4$IpP%`YpQvaCK%o}x zW2wgFphBkHUX=f1q-dkbSHH-AKqSMbMdC3p@-iCv)v^bIa=dFEuxDpyBy4x3u^*lo?)i$QKKhfxsb*qs!o0O>Ct zSuj3?z%_*V9I<0Hh5?RcWP1GvR&e)PtnO7Y?RdO;^2U6X-;%mC4IF9}GB$kD@}@Pu z7Z&GAv3Fh@e>;f+=apDJg>aLO8?&mL9*gocxZZ5JQCfJkM*(!;imVI*vmIh`a_flz zpkGCAt2M479Cdb{-M%g>EI~=;pV0ubDQt|AxxjpTVE$rw%`E@WP9pmCh9x9LQJ5ERE= z>n#AAEnnM%6aTQSjBk5Kldcls^($*f!LDD6ilXpfZT8mzJ2{G(mY5WBi3}%1*Nq*& zk-~>9NfQhFmMrFk9jR7E3E|HL1ows7tr8r=#3<{4V2VNvW|5PVOVDoqb}6WFd)(iRcO^ ztw%MeYkv2(`4~kAxQN%M??JSyHK(NO@fz?Mt(eLHUe@gm#t6Qv`0VB-%nMZGsihZ# zi{Q-J6aNlO8M`&mZ{L=suUatzc^wT|6+V%5fwzcIG_(I-Z^Ynx(-C=IqSy@X$oVXO ze&Fi{TYJ$_aRm=vK5Q3>s}dG`k1rLYtLx|`t4`7LHh6r6uc3fNwfsEfH8`Jsm;7s# zN7ohxr-a$=LLbj6oA@V|L@-h72m}KxSjjwnu83HvRG-NH@c_nb46)!}o3S<<8S}#1 zMN2s}))jt!r&Vr=*Qk%WZaMMRN^#uI+OZ2GI`YE*7E_rUR>S<2N(W>8B|3F}mX6@pk@NC0#5F6q0GM$t6Cj54FVb(a5r?~i^Jv>S# zZ3I#`!o#CWX~jL$tpM1UJN#R~kjs?-WlBQiKqdWCy`|gPVJSweX3!%k%4191Sc3I- z6b%nZ9ASs9hZlpUX479?pC4a#R7`aAS^op2&)9*o&0u+}9p}IpI;w&_*T5e{J^CPp zsO%?s>4$*`MA9DM&qkUBF1u_cwK%0)VP*+)#p45_>d8vCp!o02Shw3~YAkwu{cko8Y6t=FM}u z<~?8x{O%;sVZmuCX&mv5Jl=HDei`}CN;+~n0Yrj|a| z4{yhk#ICyQZw%As3D6PRflys#k%U;_nAVx^Df9~sLZ&#E%8fW2H}L0(1gc8jv%5Yv z&h6&ULI8zNNz!UndzOlbSoCuoh{};y$GqFL#>pu>MGI_Nm6An`76Ybyf1S_RINQ@d zJ;4114CG8495de^`Uxa_o5(AZmW}cX;6=WFw`j^pCj}5Vv@D;V(2h(G5`&#C=ZVl+ zd>vKLG+AE$;LS!>g%`?fJ2Rb(ggm4RO5!){t!Kz_ep?NIoa~e+2s|$$<20G1i3nS; zvJwJjIt*#vmmCG!vF7OX_2BN(N)8dzSv(QeSS{7OU4@?4me#Neg3%aIUUVoclKQ@` zA&fdNWj!fJ9UCy)k!$$c4xB=E>DDw6SzT znye-LM7A3Zy{av3O;JYa$VtVs;)Xz^FMd9fqL{^lty$=p8_uOZWe5+`i^J$&${9g6E((0>s+ z^xf9U089{gH!cR}7G`{GfUxH3qyl7L?LhECG&Wkazq#F$fRIb7s2@hI%uL(dID&_{ z^s#YG%U?$VJ~WYc-G(#=1#xSO?kPhk1%;Q>#Z6qd14dD|n$-Jv(U8t=-If=$FG5)0 z5-M0&gf9DzJ9vU9F&kmq65G!ZNZ$R~ArcUugfchR1&)Oay5^)A?f+yN z-XtL%BamVYsLINW_R9+jc(nXT{N*)^>wVPC-F>xk7+YGpeP_7VmR-i0~YYMdVpeKf4YJ603{3zD$peoFT8ZQl0eL0YW1Qe+pLPL`rY$ zr@rI)?_gL>G18dSl~pC)r0wZtgBU@9Mx{9opd0?{B*rR=~-o zwkF_u9kHTa?R!wrqY`dQlm9(4fr;0{6^XsHq-wQN)XEr4LoWs=e&a-@Jgfy)BS6Q+>$X`}7c`M=e80Y!(WG60koI_fp$0X$t>YQiZIc3jg=jD&Aa=4^T2cMS zc~VkU;IGo$?PUQu81&0DI9#vhtY0jKyRYxK&PYQ#=G3}aJ44FXTpajFyNZ<129h1` zTwC|4>OHE@U_K(HU%8chAz;OjgOF3a0>=tasP`?cb!tsjDd2pf@S`4uzh);;bGf-A z2@pjdiwX+9ENnD8M{ieq|3!Z|lhV+)`K(OT%FU6<%4&Wj8ezvD+`DOT565{p28tai zzy$n=)6%Z155}vFr2Rm z)eWSpQ>5oP9bf~<+yvfqfSL$B!QlRzqqgx)jRl$ z40k8k)OceMRHp>3Fv3}&r)u`|N<*uWJ1;D?*{m{nF18}2v2}U4*|BqHSZa&E4n*kt zj`=T8lk5;~@=k%}y7lR!I}c@1UBf@|yhcS=ffP12?I!jQYu>Mb0eAbu)o6+fZNwjw zEUYYF1X6D%yf!ZrvuRz^&POmvCr_`+#}#Q}h0YAWRkN!gd`AST84ORK?xP3CleM$HTdk*>d2j1{2+-6TB=pVwbitCmh^49by-X%VBl#)^1- zVtor22THEZ2qijarZs4>4%z__wm<%r2!KZnlF^%>p1R;aoK4HR*zqpkD`t(q%L!i! zamcTZD>;NmjT+SRVF$*nfrAjb+>(g?E`7gZQ5F^q(1Y4Xrj3M^k-;=Htu?W`)2+;f z(zt3?A=#QAq8)78fc&J=8$;o@@lj8$;N_UHs{Qja!85IkWc_dY0wB)xqT;-}XDcqi5a1Cr;W@p0YpOd=vCGZ84u z%YPQvrm+_%`Uhb{LzzZ-nhBX%5o7p*`cu3>Nspo^bK^T@(0C1q!I9w?Ag|V8eF6!m z&vtK4#y@l&BS2g+N#4m`=Mfj`=1p=L2Uyp|f zRP>IAe)WR&9`5z8X^$G8A%4(oJRuN6w~E(Bdh1SCCA2kk&(maJ>~-r^kV9 z3>rp$lMi4(0dBlYMM)WCNOM0{)S^I#`?cTiP}sR4Deixpp*Ubys-1vAB)8aX3;mPb zFu(YZn+7474O&{J#!fGL1>{IzBk}iR8Cek4eBuifl|lz$AzqA(CQ;x0U)W$*sYt6Z zKwc@7bZ=}1%0}4)%4=4f_O@FZQ06fZqoAqzQa}NX_y^;V(Zb#qUEVzGx5@7K%#0^J z+O0Wcv1mP4m^)!%2a5Ky5_Gx?_UYLmI9;s7jPO!Z>vjt)FMDVZ;?caJsi7H*;G6P) z9+_DxqNC%CC;st*qDZIu4&dRrkpVC4Ywu-CfHD2h+#`YH4Hy{ZAON|(=)M?OuK3nG zxU#e0TVc&-e@HTWS>V!tlkf*3J=XqXE!{9|9HLR3EdS>N#(C>X?ZRhk>QCx;0N4|< ziKkB3+F;*8fBlR@tHsGnX|TLZcs`A~gNvuMfamJ-z^={vr@j`xiQ?(6|Nb4R;g6(q zW>B{M=m`3c-oH}XU@0rCPvFI+?k{;IVfdY2RR2mb5Ht)*m}lGFAS1UmnVMlRH0?S; zC+QefEc%`3%#TSkmr>}jL`04?p#uTg=pLzz>%z+t*G`25hhUITyK7Y-4@>pu<|?FF zX#4`en`!s+KQ0?bMCL(OWvZwRS-}i#*ZJtC1L(>?ltY3X z$09*OH^HYb&>}C|S{&wFtJYkbgISCaf4<_U_D176acuh*%0@w2Zc&iiFt#4k)19n; zdT+N{{vgGKiN1=YL~nd1dBgM!Hn{7b#&Z^+j)PSR9mLu4cZ#Wz&Tj^%zX?RR-& z@=ZnM0!ZyKb%5>pBg`^ZBMGRMUL7w3<;X-`aneQ3U^K;iSelQy6f-1z~&O z_oVrfV}uQL-qirVvZ|2Ej$GyHI3q#cBvnoC6HBn!d?}fR+5&$zi7yP6@7ZT<ZDCEFAXl7iPr(an37vNLSN8{_0T|?&J#icY7R8=hWLK)K$Uv2fd-8*KD&2 ziW2yq(>_a~r^;jxmgs~2Bh(X5pa%suc)oydX|n8-yJ^anJ9`~8i#U}@S`NV2{vDe* z?F(5(h7GmdfG;4MrsR`zGhCe4d}~1=U=eO0_4hNJ%!TO+M1)Gx$9R)JIMYJQByp4t0gJFwmci%%zHDDEhx{;&di>~j@BAVZ3B#ldGuERUJ- z-#5^!TXwx_F634_mTZtI#Q%E+#edB+to%62?p=R>83M#f_C>&)|E%0w|CcuFPpmSo znz^p8tBNX7LqiSfgLUOT_#+;_mb(Kw*G~MhoMuh^zT8?jRn>zU*5Cx#8weS4dWOEFjnXg}6MsTH=v}dNo_T1X3j@#P8QA1zFoY>i!Q1~r+95wI3TthgI z&PH+o4~=(C8izG+aWB)GjN}n z0s+3VH<(EYk5|S$OY7~rm{cj(YsPww-S1wd#)&a6P=z9|D!{ycw~=P~zkI5DzKZB26hvcEq_G#Pc=MeHK&?7YKXX2(AK z78D))5$N@8j1Lcu@!u^r;}gxsLPCe~TGN!)D_9;KK{OT&H+;W)UwJ+eTDG~Z5dm{K zO*=J8EMn888iR5aZpTdFxjZ57`1fK7RKOcfg!k!gw|DM8|IK>KwA2(|o}p7{^y#Wp;|RxkQ^ z%*$h^(E+)6%i58w{hMvR&T9Lz=6Fn1oro5_P!1%#@fJ;RtaoY9BIeb;Y+v;7e;+vO zJ)eLr%(AnYX11Qd3jt+cGpBawl;N|sd zHEL+&q}SKC_hBWL{)`=;Oj*%nZ)GGsRfHPV3k?_?4ojv=T8)#-zl^fYv$)AyZ+FX( zlDX)A&(x3{ACFFuaQjQk7#+wNJ<@zqMR6Y&Uf`omiSHGDR@1h90N>pbCs@ZeZ$nTU z@S0!)`J1kH*1Z4r|4hjF-NZ9VMa)N=2&e|9;WwdZ5Bss5o6r zaj~#(r8`?75V5C4zLia`zdK}obOgf9)lwOP17Fc6dU~w6cZ5oM73;$QuCEY<)m@@G zs`dC#d$!o@ycG9Zu2xNtRrhCQv)Q(Wfj}x7%#Jh^@AdZJRC!DOhdqLV0uF<$AGj?a zQRAevNvK^UWt!TA$n|;J++VhKAGXu$^%vAla|iHq$rj*wF))JO8n6J(zI<$*uyD(V zlQ8p2^-Uw%iU;p?qIm!$H@57>%<$#8r1PeiXaxXtljYAmF!VJ)Dn3L=$ z4yV3g8;$>Nk|mjlGa2R^0%=1sJs0DaUNjv?&oDsBJ~ z-kQeJWNBFxOtgImn7xjwZI0g5r}+Yt&<2n%F9#)jzvzX_h&+6=-n#R8bmZq}`jN#w zlIp1`_nJ7cya7hfUl%Su2%bs5!qy0j1XV7>O6wbTID+*Evt}2T5^>qG7R$Kk4ZzAD zE$NKX(uVnH^=w$$m>8C1et*jtDeq~bxEt2_1cM4Nv* zC^JFgycJ1zS>wGnN&KjnZG8REkU^W!+qeG|r^gi{mPtrpoo`O#(&Y?WL(_cpPmT{t zqmAqD|4!J7tIUNx-%tm0NiKYX0#y<;w0V4$8&2$qrY^+}e1zt;zdlhN0dV($4n8XY zkbCn8qN70s^YbVFNEjLPuo(kLLj^!*c6UD}sOyR8>FITKZZDZ<^%oarqFmp7_yI<+ z!H3&(cK@dbzxBhDlK~K(@0`*AD?qo&nNfoRM@y`^Ij1xM9y0-acR(h&-RCjF6x#-( zG1*>$uJV^?W7Gl3alyZT7TUG9yASSO0vV1}!W-CPvkSHGsrbXgU437%8r+?m0~jly zfC#f)4eqJ&TI#p9qE=QK&i|&Qyz*3jXJhP4n1g-~hfecbasV zWH=94e#hQ;=yh;%eN80`yYRTuylbj!JOon~47txYU6UTK zu~(mty&#Sdn}fI?eGJ|IDV;sp#l@TDvainQIK-Se;qC3)e~ON8Zb|^$a+mxou1g=inQ5J_0PsD$wUjd1r1YnWG0)Y;20m@t^^eZ7-uy zbhXT_G!Rd(DxU%14kESV~GtGxX1-P zSOt+KK4^Lt#-NR?>vi*od5gT%bTp6#lvnJDnO8H*12wuHM;L-^4oPv{{)Gjfi;cEl zXHI6#tEG}zmRoFZ6=_E-%Kr<3NBc}7fd*juv{`5*(0c^>Y(;9CV4derNd*r3tI3+5 z1p{r|Rk>_Xsv3mdh~aD&DhXouAbtW+Q+Q^*gdrGksy_wKz>1Z{AVoerBANWK;04^_ zg8y1iILKT3@l_roW#*i~vDs^Gjwq7v5ws@kXq%at@V9!mkAAIhycUro5%qm0bGYPw z7vG)wnm%Q3XwCb*k_YQCqeX0!se>+Ad3C+C;vh+9Y_DY@|>xj>#3Q;dK_BxXEYjE5PU8}LbWU}$%Y zQ$!JT_h$NM7JTA)p&V|)Im;8Xw1nTyB9+Y5B9{CTQjw2##7h8PVki|a0ehj%E6U4@ zi-={!dvYk1Ykb^An$r$5^o0@8ry`)S#AtuzoQRq{wAUnJ<$B>Xxy1@EQi1Nki*poC z28O6@O(i}j}guyu$3k@Pmhti; z^yf8J@dohm$Lq+Eh}Ra?c4XSAX-iod4lto7JWIwT=Oe5~@)olkqnl75n*A)6h5ed8 zg*la~U-&i3pFiMgQX0OtncXDJKDF$rIiAX`66}9p4#bZM1mJui(IMG7o1{Adgr4o= zG`nAIDxG#XfM=CCyO5?XCqVknPlUqh2^H#oE-5h;6*roKA~A9tK=fL3^EbBeD&o*@`gPWh}q-W`gHj*pX(wV??$WJBRi#%e~BkG0K> z3x-*J?{P4a{D4C-vC^U17`?1DU)}NCakeOYWzc$Bgwn32I#ql*qZmD?=lNFRR85r* zDQMMm8(mf z9|!+FpYT-VJ@8V|Kx(`AUfx3Pdreko_xm6#Qz3ZeJ;qBqM&4U6gE2Mr3;vLdoXICv z;fw_f!HmU{Ws;`zdKE4$m4h5Q7p3uuM$_q<*0lcf=iAt`#qAitqvEQOlLA!eE=}|5 z^H6ejcBYEfi)lJnVm2vb>c9JTjc1ETHpDTqUh{CWNi_nO6Qa?BC(X3mhL)D?>x?YB zBrHh1|0VO-XJJ2MJ}7ApN0%z4Gf)Pu!v9AK3c{RkTIJ$t-ly4K>{rji~I7=NeJ%ToWj`Evy?VW}E{)eWw49lu(ySC|0=`N+a zB`;c~rMtVk>!e#mx|=c(h62^QNbMx>h|0&^G~7=7XBX zw61GqPtQ4x!ly&Og&ppbgS^}(5Tjg~@2>~ehQEpe`zd6YbxGh(7%U~I1t!lhZYu&f zg1GFok!X!+RFmK<{X%?!L6hdO_UP_xmR^kJ_tVRrvJ8h4L2`LA#Om-c)pvTC0)$`2 zCuG`=X13_tyRfydcxGf|jjFun2A8HSSN=UHDqZ3`tVvAj9r~tK4OW+wAvh%()myUz zh1f{4MwYUu+Xx^jP3Y!}M8kT*V~Zh?nb{JGK1i$+;Q1MPMd3fdS|**Y4q}{kiRXrw zL?mBsmYHWbikB2W<_SOl&)sh{;n~{4Llo-l;=%w)oH(ImV6zY!8KCdqGz{8L(!eMQ zR8c#?_gggUqaI|bHzl~MGGR$e-{{^kc5}BonF!X6>IzX5hiQKxS8r^&y}H6&s;$pB z!!HH5C7XU@qtPVB`A$mX6W`yLG=ZeeyGo9}$^0Lo()=J&N67tHvroBxkrpJhL3w-c z)0nAhpr3QIv0~74_ilc##%Z`SM%j)T7%w8U9A>$9kjgukS+g`E{C}yia2XYCTl&ib zA8n2`n@X={OHd$&BNjQzO4c)sjI0=dT+&3o$m*%7fjE)|ToUCM3uGSOd0f{^)qI6m za=R%jDZiAn;xin<^T@>hHlrJzxSW(ZmQw=8VsP`F5Ge>v;?rFNxUjaVYrCR6JTPy2 zd8*XZSKCSHWZVz-^jFL4BnJRtdtSq;9A^eYR79?=wg=zYNxZPR&0F?PY*M*860vYC$WYFtSP0|F+(#l?)tJKCG5H3=`$62|eeF@*BmwSlubDrrv5Qj9f-%)`C%#;mh_*PC@g?St$Y99S&r& zeKppiLgz-;r;CK=Ii%K_8Ym`>!@bHZg{YM>SH{PCi}C=Ca^MZ#O%wXj{UO|%95l8U z(k@94%eE4s!~2tSBl1{X31CQ~b=ETd4|(OVv_^dfkPJe=|m1G{tmcg1B# zgiRB~epFf~-CR;RtCf})a?FHNfYph=k9CV}quuFYzDY5Wk5&e;FA~YNyGxc0ZW{|@ zK3^oeq%Lc=45pBwko&HjK2{jjdX>RrtNGO?SUX*ccik8mG8PdS$!sHFE94lhy0$$hCmOUa{iAL=K2Of0>#$4Nu}s&PA4>hb^s1TY>m7)u?;vBtl*&UILkHRt1&;s|# zmf6L)sw(DySQu)zMJRhsD0ObVxhZTeYmqssOY*DYM0VzJzg1OX7;@_C^Y|SBxg*p` zj*E)~r-5Llw-bTAfIafd-Dtp4t0%^XIbjyJGd;+`&d_3zqmBfsnNldTK_9W)&q0{gkrOH`>+@*r++0ookiRQLRi-Q4y3< zaNlp=yrB%e8X0+fSwKUk;yP2{^c!<1tDia@S$TW8)_j}kcXKgN17-N^4dM*1c#1eU zY^Q$OhS7M29ov>ORafh62c9zXUNm=h_>}7`(JkeD!dn~P-hR#{i!yO``4#SWtM^<* zBjX%vRKNYZ!iX0Z6`%e6uUqoiXcLUZkqHnEsg62MR2cO+c3Amh?v>8t=?w1k~^_Z@MZ=w=fYqV(g0B@ z+NZtPNr~$xLc{IxYLrN)go9IO(s`E8D6BY>RVc(dJuDICto>W{%UF#!$L$a*UP!$D z*HlP|(h6&keS2O*>Xy4q4JE% zQL?(4+_BLy1u|JK+dzoG-J8gp1+l2qzL%aknnpj*PWbv}0v_}A3HIuwx&X@tx2PU~qb;!oJk@-yUkKN>LW zv=2rEY?A#yS4g9)$NOBvc?j3Z_Vq*tGVr0sRxO_{z)0ZQXUw8ilXHKH5shGAgmFJ} z_l@Qt4w8-)YUZBc21>g{VV&_!PUe`RmxU_mO1_5!x~S#rIa^>0JgRUJqd|hWkP1rQ zcI5=jQTQy|*_Q485WoLBFjgpi){S}Hzvj(!epoV7j0EYQ;4bz&LH^j?Mc8~3sJGJ> zdlk6YrWbHrR{z_vr$iouCpJ#-cC~1Ix5Qcv|76WMn$Db7^(zD>8$YhAMw+JENyK#+ znc4lscsWr%gEXFtIL#teWVLLbLB1f)wF~a~+%JRIc3}n-1%))K_$5iVts`>8BR^Az z?`V{jTa^3y5p@%43!N54-Ak9=-*1M`j685RdvI|yf-LFq2Ce6hDlEhl5^1SxaD>A8;ZLOtu){tpI|X+_ zRWBYp#xT*JxxuXi>5#aYR&^L{jJF#nGBWO*u3M4?*r0cIHMzM8I?gc6f?r`KHaxsJ zK!4BioHB8_MExMX^}!lpbqGa8o>sc;sW4NQJ%hpCoRIl} z;R5t8pN3}^H0zKt(cKvFy>}87uln836f)AZYga^A zI=M8NeRGzaO@bKR`G{qEj+K?4G!IA@i`8671bj6Ej$tt?mBzMF{pMY+=(E0m@+kS# z!>Ya?v3{zo1x@s=`_6drX&AVDDg4J zc)j|ZB{d{$z<*ZJGIWSH9~H7L{gN@f0Me_D;>*;cdA2q54_>^oWYqB$wUh99Q*^tY z+ao5PAf?P<7Ba5IkV!Nlh}pR�FER*~yxRuGW4Rj* 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

eX=6oVLhe2 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 XBrw7y@Z=&!qntT)PA&6<#ohk_hH@3q diff --git a/examples/Envelope/plot_danilov.py b/examples/Envelope/plot_danilov.py new file mode 100644 index 00000000..4f1692f3 --- /dev/null +++ b/examples/Envelope/plot_danilov.py @@ -0,0 +1,31 @@ +import numpy as np +import matplotlib.pyplot as plt + +from orbit.envelope import DanilovEnvelope + +plt.style.use("style.mplstyle") + + +envelope = DanilovEnvelope( + eps_1=20.00e-06, + eps_2=0.0, + mass=0.938, + kin_energy=1.0, + length=100.0, + line_density=0.0, + params=None, +) + +x = envelope.sample(100_000) +xmax = np.std(x, axis=0) * 3.0 +limits = list(zip(-xmax, xmax)) + +fig, axs = plt.subplots(ncols=4, nrows=4, figsize=(4, 4), constrained_layout=True) +for i in range(4): + for j in range(4): + ax = axs[i, j] + ax.hist2d(x[:, j], x[:, i], bins=50, range=[limits[j], limits[i]]) +for ax in axs.flat: + ax.set_xticks([]) + ax.set_yticks([]) +plt.show() diff --git a/py/orbit/envelope/__init__.py b/py/orbit/envelope/__init__.py index fde0f76f..7ab99299 100644 --- a/py/orbit/envelope/__init__.py +++ b/py/orbit/envelope/__init__.py @@ -6,6 +6,6 @@ from .kv import KVEnvelope from .kv import KVEnvelopeMonitor from .kv import KVEnvelopeTracker -# from .danilov import DanilovEnvelope -# from .danilov import DanilovEnvelopeMonitor -# from .danilov import DanilovEnvelopeTracker +from .danilov import DanilovEnvelope +from .danilov import DanilovEnvelopeMonitor +from .danilov import DanilovEnvelopeTracker diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py index e69de29b..8454d773 100644 --- a/py/orbit/envelope/danilov.py +++ b/py/orbit/envelope/danilov.py @@ -0,0 +1,765 @@ +"""Envelope model for {2, 0} Danilov distribution (KV distribution).""" + +import copy +import time +from typing import Callable +from typing import Iterable +#from typing import Self + +import numpy as np +import scipy.optimize +from tqdm import tqdm + +from orbit.core.bunch import Bunch + +from ..lattice import AccActionsContainer +from ..lattice import AccLattice +from ..lattice import AccNode +from ..teapot import TEAPOT_Lattice +from ..teapot import TEAPOT_MATRIX_Lattice +from ..utils import consts + +from .nodes import DanilovEnvelopeTrackerNode +from .lattice_modifications import add_danilov_envelope_tracker_nodes +from .transfer_matrix import build_unnorm_matrix_from_params_cs +from .transfer_matrix import build_unnorm_matrix_from_params_cs_2d +from .transfer_matrix import build_unnorm_matrix_from_params_lb_one_mode +from .transfer_matrix import build_norm_matrix_from_params_cs_2d +from .transfer_matrix import build_norm_matrix_from_tmat +from .transfer_matrix import is_tmat_coupled +from .transfer_matrix import calc_params_from_tmat_cs +from .utils import bunch_to_numpy +from .utils import get_perveance +from .utils import get_transfer_matrix +from .utils import build_rotation_matrix_xy + + +def env_matrix_to_vector(env_matrix: np.ndarray) -> np.ndarray: + return env_matrix.ravel() + + +def env_vector_to_matrix(env_vector: np.ndarray) -> np.ndarray: + return env_vector.reshape(4, 2) + + +def env_params_from_bunch(bunch: Bunch) -> np.ndarray: + a = bunch.x(0) + b = bunch.x(1) + e = bunch.y(0) + f = bunch.y(1) + ap = bunch.xp(0) + bp = bunch.xp(1) + ep = bunch.yp(0) + fp = bunch.yp(1) + params = [a, b, ap, bp, e, f, ep, fp] + params = np.array(params) + return params + + +class DanilovEnvelope: + """Represents Danilov distribution. + + The Danilov distribution is the limit of the KV distribution as the emittance goes to + zero in one of the planes. + """ + def __init__( + self, + eps_1: float, + eps_2: float, + mass: float, + kin_energy: float, + line_density: float, + length: float, + params: np.ndarray = None, + ) -> None: + """Constructor. + + Args: + eps_1: rms emittance in mode 1 [m * rad]. (Either eps_1 or eps_2 must be zero.) + eps_2: rms emittance in mode 2 [m * rad]. + mass : Particle mass [GeV/c^2] + kin_energy: Synchronous particle kinetic energy [GeV]. + line_density: Bunch longitudinal density [1 / m]. + length: Bunch length [m] (used to convert to Bunch object). + params: Envelope parameters [a, b, a', b', e, f, e', f']. + The coordinates of a particle on the beam envelope are parameterized as + x = a*cos(psi) + b*sin(psi), x' = a'*cos(psi) + b'*sin(psi), + y = e*cos(psi) + f*sin(psi), y' = e'*cos(psi) + f'*sin(psi), + where 0 <= psi <= 2pi. + """ + self.mass = mass + self.kin_energy = kin_energy + self.line_density = line_density + self.length = length + self.intensity = self.line_density * self.length + self.perveance = 0.0 + self.set_line_density(line_density) + + self.eps_1 = eps_1 + self.eps_2 = eps_2 + self.intrinsic_emittance = eps_1 + self.set_emittances(eps_1, eps_2) + + self.params = params + if self.params is None: + eps_x = 0.5 * self.intrinsic_emittance + eps_y = 0.5 * self.intrinsic_emittance + rx = 2.0 * np.sqrt(eps_x) + ry = 2.0 * np.sqrt(eps_y) + if self.mode == 1: + self.params = np.array([rx, 0, 0, rx, 0, -ry, +ry, 0]) + else: + self.params = np.array([rx, 0, 0, rx, 0, +ry, -ry, 0]) + + self.set_params(self.params) + + def copy(self): + return copy.deepcopy(self) + + def set_emittances(self, eps_1: float, eps_2: float) -> None: + self.eps_1 = eps_1 + self.eps_2 = eps_2 + + if self.eps_2 == 0: + self.mode = 1 + self.intrinsic_emittance = self.eps_1 + elif self.eps_1 == 0: + self.mode = 2 + self.intrinsic_emittance = self.eps_2 + else: + raise ValueError("eps_1 or eps_2 must be zero") + + def set_line_density(self, line_density: float) -> None: + self.line_density = line_density + self.intensity = self.line_density * self.length + self.perveance = get_perveance(self.mass, self.kin_energy, self.line_density) + + def set_length(self, length: float) -> None: + self.length = length + self.intensity = self.line_density * self.length + + def set_params(self, params: np.ndarray) -> None: + self.params = np.copy(params) + + # Recompute intrinsic emittances + self.intrinsic_emittance = sum(self.projected_emittances()) + if self.mode == 1: + self.set_emittances(self.intrinsic_emittance, 0.0) + else: + self.set_emittances(0.0, self.intrinsic_emittance) + + def param_matrix(self) -> np.ndarray: + """Build envelope matrix. + + The envelope matrix P defined by x = Wc, where x = [x, x', y, y']^T and + c = [cos(psi), sin(psi)], with 0 <= psi <= 2pi. This is useful because + any transformation to the phase space coordinate vector x is also done to + W. For example, if x -> Mx, then W -> MW. + """ + return env_vector_to_matrix(self.params) + + def param_vector(self, axis: int) -> np.ndarray: + """Return vector of envelope parameters [a, b, a', b', e, f, e', f'].""" + if axis is None: + return self.params + param_matrix = self.param_matrix() + return param_matrix[axis, :] + + def transform(self, matrix: np.ndarray) -> None: + """Linearly transform phase space coordinates.""" + param_matrix = self.param_matrix() + param_matrix = np.matmul(matrix, param_matrix) + self.set_params(np.ravel(param_matrix)) + + def rotate(self, angle: float) -> None: + """Apply clockwise rotation by `angle`` radians in x-y plane.""" + self.transform(build_rotation_matrix_xy(angle)) + + def projected_tilt_angle(self, axis: tuple[int, int] = (0, 2)) -> float: + """Return angle of projected ellipse.""" + a, b = self.param_vector(axis[0]) + e, f = self.param_vector(axis[1]) + return 0.5 * np.arctan2(2 * (a * e + b * f), a**2 + b**2 - e**2 - f**2) + + def projected_radii(self, axis: tuple[int, int] = (0, 2)) -> tuple[float, float]: + """Return semi-major and semi-minor axes of projected ellipse.""" + a, b = self.param_vector(axis[0]) + e, f = self.param_vector(axis[1]) + phi = self.projected_tilt_angle(axis) + _sin = np.sin(phi) + _cos = np.cos(phi) + _sin2 = _sin**2 + _cos2 = _cos**2 + xx = a**2 + b**2 + yy = e**2 + f**2 + xy = a * e + b * f + cx = np.sqrt(abs(xx * _cos2 + yy * _sin2 - 2 * xy * _sin * _cos)) + cy = np.sqrt(abs(xx * _sin2 + yy * _cos2 + 2 * xy * _sin * _cos)) + return (cx, cy) + + def projected_area(self, axis: tuple[int, int] = (0, 2)) -> float: + """Return area of projected ellipse.""" + a, b = self.param_vector(axis[0]) + e, f = self.param_vector(axis[1]) + return np.pi * abs(a * f - b * e) + + def cov(self) -> np.ndarray: + """Return covariance matrix.""" + param_matrix = self.param_matrix() + return 0.25 * np.matmul(param_matrix, param_matrix.T) + + def corr(self) -> np.ndarray: + """Return correlation matrix.""" + S = self.cov() + D = np.sqrt(np.diag(S.diagonal())) + D_inv = np.linalg.inv(D) + return np.linalg.multi_dot([D_inv, S, D_inv]) + + def projected_emittances(self) -> tuple[float, float]: + """Return rms apparent emittances eps_x, eps_y [m * rad].""" + cov_matrix = self.cov() + eps_x = np.sqrt(np.clip(np.linalg.det(cov_matrix[0:2, 0:2]), 0.0, None)) + eps_y = np.sqrt(np.clip(np.linalg.det(cov_matrix[2:4, 2:4]), 0.0, None)) + return (eps_x, eps_y) + + def intrinsic_emittances(self) -> tuple[float, float]: + """Return rms intrinsic emittances eps1, eps2 [m * rad].""" + return (self.eps_1, self.eps_2) + + def phases_xy(self) -> tuple[float, float]: + envelope = self.copy() + envelope.normalize(method="2d", scale=True) + a, b, ap, bp, e, f, ep, fp = envelope.params + phase_x = -np.arctan2(ap, a) + phase_y = -np.arctan2(ep, e) + if phase_x < 0.0: + phase_x += 2.0 * np.pi + if phase_y < 0.0: + phase_y += 2.0 * np.pi + return (phase_x, phase_y) + + def twiss_2d(self) -> dict[str, float]: + """Return twiss parameters in x-x', y-y' planes.""" + cov_matrix = self.cov() + (eps_x, eps_y) = self.projected_emittances() + + beta_x = beta_y = alpha_x = alpha_y = None + if eps_x > 0.0: + beta_x = cov_matrix[0, 0] / eps_x + alpha_x = -cov_matrix[0, 1] / eps_x + if eps_y > 0.0: + beta_y = cov_matrix[2, 2] / eps_y + alpha_y = -cov_matrix[2, 3] / eps_y + + return { + "alpha_x": alpha_x, + "beta_x": beta_x, + "alpha_y": alpha_y, + "beta_y": beta_y, + } + + def twiss_4d(self) -> dict[str, float]: + """Return Lebedev-Bogacz parameters for occupied mode.""" + cov_matrix = self.cov() + beta_lx = cov_matrix[0, 0] / self.intrinsic_emittance + beta_ly = cov_matrix[2, 2] / self.intrinsic_emittance + alpha_lx = -cov_matrix[0, 1] / self.intrinsic_emittance + alpha_ly = -cov_matrix[2, 3] / self.intrinsic_emittance + + u = 0.0 + (eps_x, eps_y) = self.projected_emittances() + if self.mode == 1: + u = eps_y / self.intrinsic_emittance + else: + u = eps_x / self.intrinsic_emittance + + (phase_x, phase_y) = self.phases_xy() + nu = abs(phase_y - phase_x) + if nu > np.pi: + nu = 2.0 * np.pi - nu + + return { + "alpha_lx": alpha_lx, + "beta_lx": beta_lx, + "alpha_ly": alpha_ly, + "beta_ly": beta_ly, + "u": u, + "nu": nu, + } + + def twiss_4d_vector(self) -> np.ndarray: + twiss_params = self.twiss_4d() + twiss_params = [ + twiss_params["alpha_lx"], + twiss_params["beta_lx"], + twiss_params["alpha_ly"], + twiss_params["beta_ly"], + twiss_params["u"], + twiss_params["nu"], + ] + twiss_params = np.array(twiss_params) + return twiss_params + + def unnorm_matrix(self, method: str = "2d") -> np.ndarray: + """Return unnormalization matrix V.""" + unnorm_matrix = None + if method == "2d": + twiss_params = self.twiss_2d() + unnorm_matrix = build_unnorm_matrix_from_params_cs(**twiss_params) + elif method == "4d": + twiss_params = self.twiss_4d() + unnorm_matrix = build_unnorm_matrix_from_params_lb_one_mode(mode=self.mode, **twiss_params) + else: + raise ValueError(f"Invalid normalization {method}") + return unnorm_matrix + + def normalize(self, method: str = "2d", scale: bool = False) -> None: + """Normalize the distribution. + + Args: + method: Normalization method {"2d", "4d"} + "2d": The x-x' and y-y' ellipses will be circles of radius sqrt(eps_x) + and sqrt(eps_y), where eps_x and eps_y are the rms projected + emittances. + "4d": The 4 x 4 covariance matrix becomes diagonal. The x-x' and y-y' + ellipses wil be circles of radius radius sqrt(eps_1) and + sqrt(eps_2), where eps_1, and eps_2 are the rms intrinsic + emittances. + scale: Whether to divide by the emittances to scale all coordinates to unit variance. + This converts all circles to unit circles. + """ + if method == "2d": + eps_x, eps_y = self.projected_emittances() + twiss_params = self.twiss_2d() + alpha_x = twiss_params["alpha_x"] + alpha_y = twiss_params["alpha_y"] + beta_x = twiss_params["beta_x"] + beta_y = twiss_params["beta_y"] + + norm_matrix = np.eye(4) + if eps_x > 0.0: + norm_matrix[0:2, 0:2] = build_norm_matrix_from_params_cs_2d(alpha_x, beta_x) + if eps_y > 0.0: + norm_matrix[2:4, 2:4] = build_norm_matrix_from_params_cs_2d(alpha_y, beta_y) + + self.transform(norm_matrix) + + if scale: + if eps_x > 0.0: + self.params[0:4] /= np.sqrt(4.0 * eps_x) + if eps_y > 0.0: + self.params[4:8] /= np.sqrt(4.0 * eps_y) + + elif method == "4d": + # Cannot invert V (singular matrix). However, we know the envelope parameters in the + # normalized frame. + r_n = np.sqrt(4.0 * self.intrinsic_emittance) + if self.mode == 1: + self.params = np.array([r_n, 0, 0, r_n, 0, 0, 0, 0]) + else: + self.params = np.array([0, 0, 0, 0, 0, r_n, r_n, 0]) + if scale: + self.params = self.params / r_n + else: + raise ValueError(f"Invalid normalization {method}") + + def set_twiss_2d(self, **twiss_params) -> None: + """Set 2D twiss parameters. + + Args: + alpha_x (optional): alpha parameter in x plane. + alpha_y (optional): alpha parameter in y plane. + beta_x (optional): beta parameter in x plane. + beta_y (optional): beta parameter in y plane. + """ + _twiss_params = self.twiss_2d() + _twiss_params.update(twiss_params) + + V = build_unnorm_matrix_from_params_cs(**_twiss_params) + self.normalize(method="2d", scale=False) + self.transform(V) + + def set_twiss_4d(self, **twiss_params) -> None: + """Set 4D twiss parameters parameters. + + Args: + alpha_lx (optional): Horizontal alpha function - / eps_l. + beta_lx (optional): Horizontal beta function / eps_l. + alpha_ly (optional): Vertical alpha_function - / eps_l. + beta_ly (optional): Vertical beta function - / eps_l. + u (optional): Coupling parameter in range [0, 1]. + If eps_1 > 0: u = eps_y / eps_1. + If eps_2 > 0: u = eps_x / eps_1. + nu (optional): The x-y phase difference in range [0, pi]. + """ + _twiss_params = self.twiss_4d() + _twiss_params.update(twiss_params) + + V = build_unnorm_matrix_from_params_lb_one_mode(mode=self.mode, **twiss_params) + self.normalize(method="4d", scale=False) + self.transform(V) + + def set_twiss_4d_vector(self, twiss_params: np.ndarray) -> None: + keys = ["alpha_lx", "beta_lx", "alpha_ly", "beta_ly", "u", "nu"] + + twiss_params_dict = {} + for i, key in enumerate(keys): + twiss_params_dict[key] = twiss_params[i] + + return self.set_twiss_4d(**twiss_params_dict) + + def set_cov(self, cov_matrix: np.ndarray, verbose: int = 0) -> scipy.optimize.OptimizeResult: + """Set envelope parameters from covariance matrix.""" + + def loss_function(params: np.ndarray, cov_matrix: np.ndarray) -> np.ndarray: + self.set_params(params) + loss = np.mean(np.abs(cov_matrix - self.cov())) + loss = loss * 1.00e06 + return loss + + result = scipy.optimize.least_squares( + loss_function, self.params, args=(cov_matrix,), xtol=1.00e-12, verbose=verbose + ) + return result + + def get_coordinates(self, psi: float = 0.0) -> np.ndarray: + """Return phase space coordinates of particle on envelope. + + psi is in the range [0, 2 * pi]. + """ + W = self.param_matrix() + c = [np.cos(psi), np.sin(psi)] + return np.matmul(W, c) + + def sample(self, size: int) -> np.ndarray: + X = np.random.normal(size=(size, 4)) + X = X / np.linalg.norm(X, axis=1)[:, None] + X = X / np.std(X, axis=0) + + A = np.sqrt(np.diag([self.eps_1, self.eps_1, self.eps_2, self.eps_2])) + V = self.unnorm_matrix(method="4d") + print(V) + + X = np.matmul(X, A.T) + X = np.matmul(X, V.T) + return X + + def from_bunch(self, bunch: Bunch) -> None: + """Set the envelope parameters from a Bunch object.""" + self.set_params(env_params_from_bunch(bunch)) + + def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: + """Create Bunch object from envelope parameters. + + Args: + size: Number of macroparticles in the bunch. + These are the number of "test"particles not counting the first particle, + which stores the envelope parameters. + env: Whether first two particles store envelope parameters. + + Returns: + Bunch with sampled particles. + """ + bunch = Bunch() + bunch.mass(self.mass) + bunch.getSyncParticle().kinEnergy(self.kin_energy) + + if env: + a, b, ap, bp, e, f, ep, fp = self.params + bunch.addParticle(a, ap, e, ep, 0.0, 0.0) + bunch.addParticle(b, bp, f, fp, 0.0, 0.0) + + if size: + particles = np.zeros((size, 6)) + particles[:, :4] = self.sample(size) + particles[:, 4] = self.length * np.random.uniform(-0.5, 0.5, size=size) + print(np.std(particles, axis=0)) + for i in range(size): + bunch.addParticle(*particles[i, :]) + + macrosize = self.intensity / size + if self.intensity == 0.0: + macrosize = 1.0 + bunch.macroSize(macrosize) + + return bunch + + +class DanilovEnvelopeMonitor: + def __init__(self, verbose: int = 0) -> None: + self.verbose = verbose + self.distance = 0.0 + self._pos_old = 0.0 + self._pos_new = 0.0 + + self.history = {} + for key in [ + "s", + "xrms", + "yrms", + "cov_00", + "cov_01", + "cov_02", + "cov_03", + "cov_11", + "cov_12", + "cov_13", + "cov_22", + "cov_23", + "cov_33", + "epsx", + "epsy", + "rxy", + ]: + self.history[key] = [] + + def package(self) -> None: + history = copy.deepcopy(self.history) + for key in history: + history[key] = np.array(history[key]) + history["s"] -= history["s"][0] + return history + + def __call__(self, params_dict: dict) -> None: + bunch = params_dict["bunch"] + node = params_dict["node"] + + self._pos_new = params_dict["path_length"] + if self._pos_old > self._pos_new: + self._pos_old = 0.0 + self.distance += self._pos_new - self._pos_old + self._pos_old = self._pos_new + + params = env_params_from_bunch(bunch) + param_matrix = env_vector_to_matrix(params) + cov_matrix = 0.25 * np.matmul(param_matrix, param_matrix.T) + + for i in range(4): + for j in range(i, 4): + key = f"cov_{i}{j}" + self.history[key].append(cov_matrix[i, j]) + + self.history["s"].append(self.distance) + self.history["xrms"].append(np.sqrt(cov_matrix[0, 0])) + self.history["yrms"].append(np.sqrt(cov_matrix[2, 2])) + self.history["epsx"].append(np.sqrt(np.linalg.det(cov_matrix[0:2, 0:2]))) + self.history["epsy"].append(np.sqrt(np.linalg.det(cov_matrix[2:4, 2:4]))) + self.history["rxy"].append( + self.history["cov_02"][-1] + / np.sqrt(self.history["cov_00"][-1] * self.history["cov_22"][-1]) + ) + + if self.verbose: + message = "" + message += "s={:0.3f} ".format(self.history["s"][-1]) + message += "xrms={:0.3f} ".format(self.history["xrms"][-1]) + message += "yrms={:0.3f} ".format(self.history["yrms"][-1]) + + +class DanilovEnvelopeTracker: + def __init__(self, lattice: AccLattice, path_length_max: float = None) -> None: + self.lattice = lattice + self.nodes = self.add_nodes(path_length_min=1.00e-06, path_length_max=path_length_max) + + # Bounds on LB twiss parameters + pad = 1.00e-05 + alpha_min = -np.inf + alpha_max = +np.inf + beta_min = pad + beta_max = np.inf + u_min = pad + u_max = 1.0 - pad + nu_min = pad + nu_max = np.pi - pad + self.twiss_lb = (alpha_min, beta_min, alpha_min, beta_min, u_min, nu_min) + self.twiss_ub = (alpha_max, beta_max, alpha_max, beta_max, u_max, nu_max) + + def add_nodes( + self, + path_length_min: float, + path_length_max: float, + ) -> list[DanilovEnvelopeTrackerNode]: + + self.nodes = add_danilov_envelope_tracker_nodes( + lattice=self.lattice, + path_length_min=path_length_min, + path_length_max=path_length_max, + perveance=0.0, # will update based on envelope + ) + return self.nodes + + def toggle_nodes(self, setting: bool) -> None: + for node in self.nodes: + node.active = setting + + def update_nodes(self, envelope: DanilovEnvelope) -> None: + for node in self.nodes: + node.setPerveance(envelope.perveance) + + def track( + self, + envelope: DanilovEnvelope, + periods: int = 1, + history: bool = False, + ) -> None | dict[str, np.ndarray]: + + self.update_nodes(envelope) + + monitor = DanilovEnvelopeMonitor() + action_container = AccActionsContainer() + if history: + action_container.addAction(monitor, AccActionsContainer.ENTRANCE) + action_container.addAction(monitor, AccActionsContainer.EXIT) + + bunch = envelope.to_bunch() + for period in range(periods): + self.lattice.trackBunch(bunch, actionContainer=action_container) + + envelope.from_bunch(bunch) + + if history: + return monitor.package() + + def transfer_matrix(self, envelope: DanilovEnvelope) -> np.ndarray: + bunch = envelope.to_bunch(size=0, env=True) + + if envelope.perveance == 0: + self.toggle_nodes(False) + matrix = get_transfer_matrix(self.lattice, bunch) + self.toggle_nodes(True) + return matrix + + step_arr = np.ones(6) * 1.00e-06 + step_reduce = 20.0 + + bunch.addParticle(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(step_arr[0] / step_reduce, 0.0, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, step_arr[1] / step_reduce, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, step_arr[2] / step_reduce, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, 0.0, step_arr[3] / step_reduce, 0.0, 0.0) + bunch.addParticle(step_arr[0], 0.0, 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, step_arr[1], 0.0, 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, step_arr[2], 0.0, 0.0, 0.0) + bunch.addParticle(0.0, 0.0, 0.0, step_arr[3], 0.0, 0.0) + + self.lattice.trackBunch(bunch) + + X = bunch_to_numpy(bunch) + X = X[:, (0, 1, 2, 3)] + X = X[2:, :] # ignore first two particles, which track envelope parameters + + M = np.zeros((4, 4)) + for i in range(4): + for j in range(4): + x1 = step_arr[i] / step_reduce + x2 = step_arr[i] + y0 = X[0, j] + y1 = X[i + 1, j] + y2 = X[i + 1 + 4, j] + M[j, i] = ((y1 - y0) * x2 * x2 - (y2 - y0) * x1 * x1) / (x1 * x2 * (x2 - x1)) + return M + + def match_zero_sc(self, envelope: DanilovEnvelope, method: str = "auto") -> None: + self.toggle_nodes(False) + bunch = Bunch() + bunch.mass(envelope.mass) + bunch.getSyncParticle().kinEnergy(envelope.kin_energy) + transfer_matrix = get_transfer_matrix(self.lattice, bunch) + self.toggle_nodes(True) + + # Match to the bare lattice. + if method == "auto": + if is_tmat_coupled(transfer_matrix): + method = "4d" + else: + method = "2d" + + if method == "2d": + twiss_params = calc_params_from_tmat_cs(transfer_matrix) + envelope.set_twiss_2d(**twiss_params) + elif method == "4d": + norm_matrix = build_norm_matrix_from_tmat(transfer_matrix) + norm_matrix_inv = np.linalg.inv(norm_matrix) + envelope.normalize(method="4d") + envelope.transform(norm_matrix_inv) + else: + raise ValueError + + def match( + self, + envelope: DanilovEnvelope, + periods: int = 1, + method: str = "least_squares", + **kwargs + ) -> None: + + if envelope.intensity == 0.0: + return self.match_zero_sc(envelope) + + def loss_function(theta: np.ndarray) -> float: + envelope.set_twiss_4d_vector(theta) + envelope_copy = envelope.copy() + + cov_matrix_init = envelope_copy.cov() + + loss = 0.0 + for period in range(periods): + self.track(envelope_copy) + cov_matrix = envelope_copy.cov() + loss += np.mean(np.square(cov_matrix - cov_matrix_init)) + loss /= periods + loss *= 1.00e06 + return loss + + if method == "least_squares": + # kwargs.setdefault("xtol", 1e-8) + # kwargs.setdefault("ftol", 1e-8) + # kwargs.setdefault("gtol", 1e-8) + kwargs.setdefault("verbose", 2) + + result = scipy.optimize.least_squares( + loss_function, + envelope.twiss_4d_vector(), + bounds=(self.twiss_lb, self.twiss_ub), + **kwargs, + ) + + elif method == "replace_avg": + periods_avg = kwargs.get("periods_avg", 20) + iters = kwargs.get("iters", 20) + rtol = kwargs.get("rtol", 1.00e-03) + + converged = False + message = "" + theta_old = envelope.twiss_4d_vector() + + for iteration in range(iters): + theta_tbt = np.zeros((periods_avg + 1, 6)) + for i in range(theta_tbt.shape[0]): + self.track(envelope) + theta_tbt[i, :] = envelope.twiss_4d_vector() + + theta = np.mean(theta_tbt, axis=0) + envelope.set_twiss_4d_vector(theta) + + loss = loss_function(theta) + + # Check relative change in parameter vector norm + theta_norm = np.linalg.norm(theta) + theta_norm_old = np.linalg.norm(theta_old) + + theta_norm_rel_change = abs(theta_norm - theta_norm_old) / ( + theta_norm_old + 1.00e-15 + ) + if theta_norm_rel_change < rtol: + converged = True + message = f"Relative change in parameter vector norm {theta_norm_rel_change} < rtol ({rtol})" + + print("{} {} {}".format(iteration, loss, theta_norm)) + + if converged: + print("CONVERGED") + print(message) + break + + theta_old = np.copy(theta) \ No newline at end of file diff --git a/py/orbit/envelope/meson.build b/py/orbit/envelope/meson.build index 99dddeed..0fa716c1 100644 --- a/py/orbit/envelope/meson.build +++ b/py/orbit/envelope/meson.build @@ -4,6 +4,7 @@ py_sources = files([ 'lattice_modifications.py', 'kv.py', 'danilov.py', + 'transfer_matrix.py', 'utils.py', ]) diff --git a/py/orbit/envelope/transfer_matrix.py b/py/orbit/envelope/transfer_matrix.py new file mode 100644 index 00000000..beb084c7 --- /dev/null +++ b/py/orbit/envelope/transfer_matrix.py @@ -0,0 +1,205 @@ +import numpy as np + + +def is_tmat_coupled(M: np.ndarray) -> bool: + if M.shape[0] < 4: + return False + + mask = np.zeros(M.shape) + for i in range(0, M.shape[0], 2): + mask[i : i + 2, i : i + 2] = 1.0 + + return np.any(np.ma.masked_array(M, mask=mask)) + + +def is_tmat_stable(M: np.ndarray, tol: float = 1.00e-08) -> np.ndarray: + return all_eigvals_on_unit_circle(np.linalg.eigenvalues(M), tol=tol) + + +def is_tmat_symplectic(M: np.ndarray, tol: float = 1.00e-06) -> bool: + U = build_unit_symplectic_matrix(M.shape[0]) + return np.isclose(U - np.linalg.multi_dot([M.T, U, M])) + + +def build_rotation_matrix(angle: float) -> np.ndarray: + c, s = np.cos(angle), np.sin(angle) + return np.array([[c, s], [-s, c]]) + + +def build_unit_symplectic_matrix(ndim: int) -> np.ndarray: + U = np.zeros((ndim, ndim)) + for i in range(0, ndim, 2): + U[i : i + 2, i : i + 2] = [[0.0, 1.0], [-1.0, 0.0]] + return U + + +def build_phase_advance_matrix(*phase_advances) -> np.ndarray: + ndim = 2 * len(phase_advances) + M = np.zeros((ndim, ndim)) + for i in range(0, ndim, 2): + M[i : i + 2, i : i + 2] = build_rotation_matrix(phase_advances[i]) + return M + + +def build_unnorm_matrix_from_eigvecs(v1: np.ndarray, v2: np.ndarray) -> np.ndarray: + V = np.zeros((4, 4)) + V[:, 0] = +np.real(v1) + V[:, 1] = -np.imag(v1) + V[:, 2] = +np.real(v2) + V[:, 3] = -np.imag(v2) + return V + + +def build_unnorm_matrix_from_tmat(M: np.ndarray) -> np.ndarray: + eigvals, eigvecs = np.linalg.eig(M) + v1 = eigvecs[:, 0] + v2 = eigvecs[:, 2] + v1 = normalize_eigvec(v1) + v2 = normalize_eigvec(v2) + return build_unnorm_matrix_from_eigvecs(v1, v2) + + +def build_unnorm_matrix_from_params_cs_2d(alpha: float, beta: float) -> np.ndarray: + return np.array([[beta, 0.0], [-alpha, 1.0]]) / np.sqrt(beta) + + +def build_unnorm_matrix_from_params_cs( + alpha_x: float, + beta_x: float, + alpha_y: float, + beta_y: float, +) -> np.ndarray: + V = np.zeros((4, 4)) + V[0:2, 0:2] = build_unnorm_matrix_from_params_cs_2d(alpha_x, beta_x) + V[2:4, 2:4] = build_unnorm_matrix_from_params_cs_2d(alpha_y, beta_y) + return V + + +def build_unnorm_matrix_from_params_lb_one_mode( + alpha_lx: float, + beta_lx: float, + alpha_ly: float, + beta_ly: float, + u: float, + nu: float, + mode: int, +) -> np.ndarray: + + V = np.zeros((4, 4)) + if mode == 1: + V[0, 0] = np.sqrt(beta_lx) + V[0, 1] = 0.0 + V[1, 0] = -alpha_lx / np.sqrt(beta_lx) + V[1, 1] = (1.0 - u) / np.sqrt(beta_lx) + V[2, 0] = +np.sqrt(beta_ly) * np.cos(nu) + V[2, 1] = -np.sqrt(beta_ly) * np.sin(nu) + V[3, 0] = (u * np.sin(nu) - alpha_ly * np.cos(nu)) / np.sqrt(beta_ly) + V[3, 1] = (u * np.cos(nu) + alpha_ly * np.sin(nu)) / np.sqrt(beta_ly) + elif mode == 2: + V[0, 2] = +np.sqrt(beta_lx) * np.cos(nu) + V[0, 3] = -np.sqrt(beta_lx) * np.sin(nu) + V[1, 2] = (u * np.sin(nu) - alpha_lx * np.cos(nu)) / np.sqrt(beta_lx) + V[1, 3] = (u * np.cos(nu) + alpha_lx * np.sin(nu)) / np.sqrt(beta_lx) + V[2, 2] = np.sqrt(beta_ly) + V[2, 3] = 0.0 + V[3, 2] = -alpha_ly / np.sqrt(beta_ly) + V[3, 3] = (1.0 - u) / np.sqrt(beta_ly) + return V + + +def build_norm_matrix_from_eigvecs(*args, **kwargs) -> np.ndarray: + return np.linalg.inv(build_unnorm_matrix_from_eigvecs(*args, **kwargs)) + + +def build_norm_matrix_from_tmat(*args, **kwargs) -> np.ndarray: + return np.linalg.inv(build_unnorm_matrix_from_tmat(*args, **kwargs)) + + +def build_norm_matrix_from_params_cs_2d(*args, **kwargs) -> np.ndarray: + return np.linalg.inv(build_unnorm_matrix_from_params_cs_2d(*args, **kwargs)) + + +def build_norm_matrix_from_params_cs(*args, **kwargs) -> np.ndarray: + return np.linalg.inv(build_unnorm_matrix_from_params_cs(*args, **kwargs)) + + +def normalize_eigvec(v: np.ndarray) -> np.ndarray: + U = build_unit_symplectic_matrix(len(v)) + + def _norm(v): + return np.linalg.multi_dot([np.conj(v), U, v]) + + if _norm(v) > 0.0: + v = np.conj(v) + + v *= np.sqrt(2.0 / np.abs(_norm(v))) + assert np.isclose(np.imag(_norm(v)), -2.0) + assert np.isclose(np.real(_norm(v)), +0.0) + return v + + +def all_eigvals_on_unit_circle(eigvals: np.ndarray, tol: float = 1.00e-08) -> bool: + for eigval in eigvals: + if abs(np.linalg.norm(eigval) - 1.0) > tol: + return False + return True + + +def eigtune_from_eigval(eigval: float) -> float: + return np.arccos(np.real(eigval)) / (2.0 * np.pi) + + +def calc_params_from_tmat_cs_2d(M: np.ndarray) -> np.ndarray: + params = dict() + cos_phi = (M[0, 0] + M[1, 1]) / 2.0 + sign = 1.0 + if abs(M[0, 1]) != 0: + sign = M[0, 1] / abs(M[0, 1]) + sin_phi = sign * np.sqrt(1.0 - cos_phi**2) + beta = M[0, 1] / sin_phi + alpha = (M[0, 0] - M[1, 1]) / (2.0 * sin_phi) + params["alpha"] = alpha + params["beta"] = beta + params["tune"] = np.arccos(cos_phi) / (2.0 * np.pi) * sign + return params + + +def calc_params_from_tmat_cs(M: np.ndarray) -> np.ndarray: + params_x = calc_params_from_tmat_cs_2d(M[0:2, 0:2]) + params_y = calc_params_from_tmat_cs_2d(M[2:4, 2:4]) + return { + "alpha_x": params_x["alpha"], + "alpha_y": params_y["alpha"], + "beta_x": params_x["beta"], + "beta_y": params_y["beta"], + } + + +def calc_params_from_tmat_lb(M: np.ndarray) -> dict[str, float]: + V_inv = build_unnorm_matrix_from_tmat(M) + V = np.linalg.inv(V_inv) + + beta_1x = V[0, 0] ** 2 + beta_2y = V[2, 2] ** 2 + alpha_1x = -np.sqrt(beta_1x) * V[1, 0] + alpha_2y = -np.sqrt(beta_2y) * V[3, 2] + u = 1.0 - (V[0, 0] * V[1, 1]) + nu1 = np.arctan2(-V[2, 1], V[2, 0]) + nu2 = np.arctan2(-V[0, 3], V[0, 2]) + beta_1y = (V[2, 0] / np.cos(nu1)) ** 2 + beta_2x = (V[0, 2] / np.cos(nu2)) ** 2 + alpha_1y = (u * np.sin(nu1) - V[3, 0] * np.sqrt(beta_1y)) / np.cos(nu1) + alpha_2x = (u * np.sin(nu2) - V[1, 2] * np.sqrt(beta_2x)) / np.cos(nu2) + return { + "alpha_1x": alpha_1x, + "alpha_1y": alpha_1y, + "alpha_2x": alpha_2x, + "alpha_2y": alpha_2y, + "beta_1x": beta_1x, + "beta_1y": beta_1y, + "beta_2x": beta_2x, + "beta_2y": beta_2y, + "u": u, + "nu1": nu1, + "nu2": nu2, + } \ No newline at end of file From ea5b1c7ce5a697e4f63e4c102cb653afbd7be54d Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 21:55:09 -0400 Subject: [PATCH 23/34] Add docstring to orbit.envelope module --- py/orbit/envelope/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/py/orbit/envelope/__init__.py b/py/orbit/envelope/__init__.py index 7ab99299..d8c75373 100644 --- a/py/orbit/envelope/__init__.py +++ b/py/orbit/envelope/__init__.py @@ -1,3 +1,4 @@ +"""Envelope tracking module.""" from .nodes import EnvelopeTrackerNode from .nodes import KVEnvelopeTrackerNode from .nodes import DanilovEnvelopeTrackerNode From d15259db206fab77c8aee6ffd50f79c677fab983 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 21:58:45 -0400 Subject: [PATCH 24/34] Formatting --- py/orbit/envelope/__init__.py | 1 + py/orbit/envelope/danilov.py | 44 +++++++++++----------- py/orbit/envelope/kv.py | 28 +++++++------- py/orbit/envelope/lattice_modifications.py | 12 ++---- py/orbit/envelope/nodes.py | 4 +- py/orbit/envelope/transfer_matrix.py | 12 +++--- py/orbit/envelope/utils.py | 2 +- 7 files changed, 47 insertions(+), 56 deletions(-) diff --git a/py/orbit/envelope/__init__.py b/py/orbit/envelope/__init__.py index d8c75373..553906b2 100644 --- a/py/orbit/envelope/__init__.py +++ b/py/orbit/envelope/__init__.py @@ -1,4 +1,5 @@ """Envelope tracking module.""" + from .nodes import EnvelopeTrackerNode from .nodes import KVEnvelopeTrackerNode from .nodes import DanilovEnvelopeTrackerNode diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py index 8454d773..05e8bbf4 100644 --- a/py/orbit/envelope/danilov.py +++ b/py/orbit/envelope/danilov.py @@ -1,10 +1,11 @@ -"""Envelope model for {2, 0} Danilov distribution (KV distribution).""" +"""Envelope model for Danilov distribution.""" import copy import time from typing import Callable from typing import Iterable -#from typing import Self + +# from typing import Self import numpy as np import scipy.optimize @@ -58,10 +59,11 @@ def env_params_from_bunch(bunch: Bunch) -> np.ndarray: class DanilovEnvelope: """Represents Danilov distribution. - - The Danilov distribution is the limit of the KV distribution as the emittance goes to + + The Danilov distribution is the limit of the KV distribution as the emittance goes to zero in one of the planes. """ + def __init__( self, eps_1: float, @@ -81,7 +83,7 @@ def __init__( kin_energy: Synchronous particle kinetic energy [GeV]. line_density: Bunch longitudinal density [1 / m]. length: Bunch length [m] (used to convert to Bunch object). - params: Envelope parameters [a, b, a', b', e, f, e', f']. + params: Envelope parameters [a, b, a', b', e, f, e', f']. The coordinates of a particle on the beam envelope are parameterized as x = a*cos(psi) + b*sin(psi), x' = a'*cos(psi) + b'*sin(psi), y = e*cos(psi) + f*sin(psi), y' = e'*cos(psi) + f'*sin(psi), @@ -119,7 +121,7 @@ def copy(self): def set_emittances(self, eps_1: float, eps_2: float) -> None: self.eps_1 = eps_1 self.eps_2 = eps_2 - + if self.eps_2 == 0: self.mode = 1 self.intrinsic_emittance = self.eps_1 @@ -128,7 +130,7 @@ def set_emittances(self, eps_1: float, eps_2: float) -> None: self.intrinsic_emittance = self.eps_2 else: raise ValueError("eps_1 or eps_2 must be zero") - + def set_line_density(self, line_density: float) -> None: self.line_density = line_density self.intensity = self.line_density * self.length @@ -147,7 +149,7 @@ def set_params(self, params: np.ndarray) -> None: self.set_emittances(self.intrinsic_emittance, 0.0) else: self.set_emittances(0.0, self.intrinsic_emittance) - + def param_matrix(self) -> np.ndarray: """Build envelope matrix. @@ -308,7 +310,9 @@ def unnorm_matrix(self, method: str = "2d") -> np.ndarray: unnorm_matrix = build_unnorm_matrix_from_params_cs(**twiss_params) elif method == "4d": twiss_params = self.twiss_4d() - unnorm_matrix = build_unnorm_matrix_from_params_lb_one_mode(mode=self.mode, **twiss_params) + unnorm_matrix = build_unnorm_matrix_from_params_lb_one_mode( + mode=self.mode, **twiss_params + ) else: raise ValueError(f"Invalid normalization {method}") return unnorm_matrix @@ -365,7 +369,7 @@ def normalize(self, method: str = "2d", scale: bool = False) -> None: def set_twiss_2d(self, **twiss_params) -> None: """Set 2D twiss parameters. - + Args: alpha_x (optional): alpha parameter in x plane. alpha_y (optional): alpha parameter in y plane. @@ -452,7 +456,7 @@ def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: """Create Bunch object from envelope parameters. Args: - size: Number of macroparticles in the bunch. + size: Number of macroparticles in the bunch. These are the number of "test"particles not counting the first particle, which stores the envelope parameters. env: Whether first two particles store envelope parameters. @@ -597,12 +601,12 @@ def update_nodes(self, envelope: DanilovEnvelope) -> None: node.setPerveance(envelope.perveance) def track( - self, - envelope: DanilovEnvelope, - periods: int = 1, + self, + envelope: DanilovEnvelope, + periods: int = 1, history: bool = False, ) -> None | dict[str, np.ndarray]: - + self.update_nodes(envelope) monitor = DanilovEnvelopeMonitor() @@ -686,13 +690,9 @@ def match_zero_sc(self, envelope: DanilovEnvelope, method: str = "auto") -> None raise ValueError def match( - self, - envelope: DanilovEnvelope, - periods: int = 1, - method: str = "least_squares", - **kwargs + self, envelope: DanilovEnvelope, periods: int = 1, method: str = "least_squares", **kwargs ) -> None: - + if envelope.intensity == 0.0: return self.match_zero_sc(envelope) @@ -762,4 +762,4 @@ def loss_function(theta: np.ndarray) -> float: print(message) break - theta_old = np.copy(theta) \ No newline at end of file + theta_old = np.copy(theta) diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index d3bb56bd..f18ca7d3 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -5,7 +5,8 @@ import time from typing import Callable from typing import Iterable -#from typing import Self + +# from typing import Self import numpy as np import scipy.optimize @@ -32,6 +33,7 @@ class KVEnvelope: """Models KV distribution.""" + def __init__( self, eps_x: float, @@ -43,7 +45,7 @@ def __init__( params: Iterable[float] = None, ) -> None: """Constructor. - + Args: eps_x: RMS emittance in x plane. eps_y: RMS emittance in y plane. @@ -51,7 +53,7 @@ def __init__( kin_energy: Synchronous particle kinetic energy [GeV]. line_density: Bunch line density [m]. length: Bunch length [m] (used to convert to Bunch object). - params: The envelope parameters [cx, cx', cy, cy']. + params: The envelope parameters [cx, cx', cy, cy']. The cx and cy parameters represent the envelope extent along the x and y axis; cx' and cy' are their derivatives with respect to the distance x. """ @@ -81,7 +83,7 @@ def set_line_density(self, line_density: float) -> None: def set_length(self, length: float) -> None: self.length = length self.intensity = self.line_density * self.length - + def set_params(self, params: np.ndarray) -> None: self.params = np.copy(params) @@ -170,7 +172,7 @@ def sample(self, size: int) -> np.ndarray: V = np.linalg.inv(V_inv) A = np.sqrt(np.diag([eps_x, eps_x, eps_y, eps_y])) - + X = np.random.normal(size=(size, 4)) X /= np.linalg.norm(X, axis=1)[:, None] X /= np.std(X, axis=0) @@ -191,7 +193,7 @@ def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: """Create Bunch object from envelope parameters. Args: - size: Number of macroparticles in the bunch. + size: Number of macroparticles in the bunch. These are the number of "test"particles not counting the first particle, which stores the envelope parameters. env: Whether first two particles store envelope parameters. @@ -269,7 +271,7 @@ class KVEnvelopeTracker: def __init__(self, lattice: AccLattice, path_length_max: float = None) -> None: self.lattice = lattice self.nodes = self.add_nodes( - path_length_min=1.00e-06, + path_length_min=1.00e-06, path_length_max=path_length_max, ) @@ -314,8 +316,8 @@ def update_nodes(self, envelope: KVEnvelope) -> None: def track( self, - envelope: KVEnvelope, - periods: int = 1, + envelope: KVEnvelope, + periods: int = 1, history: bool = False, ) -> None | dict[str, np.ndarray]: self.update_nodes(envelope) @@ -388,11 +390,7 @@ def match_zero_sc(self, envelope: KVEnvelope) -> None: envelope.set_twiss(alpha_x, beta_x, alpha_y, beta_y) def match( - self, - envelope: KVEnvelope, - periods: int = 1, - method: str = "least_squares", - **kwargs + self, envelope: KVEnvelope, periods: int = 1, method: str = "least_squares", **kwargs ) -> None: if envelope.perveance == 0.0: return self.match_zero_sc(envelope) @@ -426,4 +424,4 @@ def loss_function(params: np.ndarray) -> np.ndarray: **kwargs, ) else: - raise ValueError \ No newline at end of file + raise ValueError diff --git a/py/orbit/envelope/lattice_modifications.py b/py/orbit/envelope/lattice_modifications.py index b2b59fca..078bccd6 100644 --- a/py/orbit/envelope/lattice_modifications.py +++ b/py/orbit/envelope/lattice_modifications.py @@ -90,10 +90,7 @@ def add_envelope_tracker_nodes( def add_kv_envelope_tracker_nodes( - lattice: AccLattice, - path_length_max: float = None, - path_length_min: float = 1.00e-06, - **kwargs + lattice: AccLattice, path_length_max: float = None, path_length_min: float = 1.00e-06, **kwargs ) -> None: tracker_nodes = add_envelope_tracker_nodes( lattice=lattice, @@ -110,10 +107,7 @@ def add_kv_envelope_tracker_nodes( def add_danilov_envelope_tracker_nodes( - lattice: AccLattice, - path_length_max: float = None, - path_length_min: float = 1.00e-06, - **kwargs + lattice: AccLattice, path_length_max: float = None, path_length_min: float = 1.00e-06, **kwargs ) -> None: tracker_nodes = add_envelope_tracker_nodes( lattice=lattice, @@ -126,4 +120,4 @@ def add_danilov_envelope_tracker_nodes( name = "".join([tracker_node.getName(), ":", "danilov_envelope_tracker"]) tracker_node.setName(name) lattice.initialize() - return tracker_nodes \ No newline at end of file + return tracker_nodes diff --git a/py/orbit/envelope/nodes.py b/py/orbit/envelope/nodes.py index ecd4c919..faad7882 100644 --- a/py/orbit/envelope/nodes.py +++ b/py/orbit/envelope/nodes.py @@ -52,7 +52,7 @@ def setPerveance(self, perveance: float) -> None: def setEmittances(self, eps_x: float, eps_y: float) -> None: self.tracker.setEmittanceX(4.0 * eps_x) self.tracker.setEmittanceY(4.0 * eps_y) - + class DanilovEnvelopeTrackerNode(EnvelopeTrackerNode): def __init__(self, perveance: float, **kwargs) -> None: @@ -61,5 +61,3 @@ def __init__(self, perveance: float, **kwargs) -> None: def setPerveance(self, perveance: float) -> None: self.tracker.setPerveance(perveance) - - \ No newline at end of file diff --git a/py/orbit/envelope/transfer_matrix.py b/py/orbit/envelope/transfer_matrix.py index beb084c7..d4051e05 100644 --- a/py/orbit/envelope/transfer_matrix.py +++ b/py/orbit/envelope/transfer_matrix.py @@ -4,11 +4,11 @@ def is_tmat_coupled(M: np.ndarray) -> bool: if M.shape[0] < 4: return False - + mask = np.zeros(M.shape) for i in range(0, M.shape[0], 2): mask[i : i + 2, i : i + 2] = 1.0 - + return np.any(np.ma.masked_array(M, mask=mask)) @@ -58,7 +58,7 @@ def build_unnorm_matrix_from_tmat(M: np.ndarray) -> np.ndarray: v2 = normalize_eigvec(v2) return build_unnorm_matrix_from_eigvecs(v1, v2) - + def build_unnorm_matrix_from_params_cs_2d(alpha: float, beta: float) -> np.ndarray: return np.array([[beta, 0.0], [-alpha, 1.0]]) / np.sqrt(beta) @@ -105,7 +105,7 @@ def build_unnorm_matrix_from_params_lb_one_mode( V[3, 2] = -alpha_ly / np.sqrt(beta_ly) V[3, 3] = (1.0 - u) / np.sqrt(beta_ly) return V - + def build_norm_matrix_from_eigvecs(*args, **kwargs) -> np.ndarray: return np.linalg.inv(build_unnorm_matrix_from_eigvecs(*args, **kwargs)) @@ -122,7 +122,7 @@ def build_norm_matrix_from_params_cs_2d(*args, **kwargs) -> np.ndarray: def build_norm_matrix_from_params_cs(*args, **kwargs) -> np.ndarray: return np.linalg.inv(build_unnorm_matrix_from_params_cs(*args, **kwargs)) - + def normalize_eigvec(v: np.ndarray) -> np.ndarray: U = build_unit_symplectic_matrix(len(v)) @@ -202,4 +202,4 @@ def calc_params_from_tmat_lb(M: np.ndarray) -> dict[str, float]: "u": u, "nu1": nu1, "nu2": nu2, - } \ No newline at end of file + } diff --git a/py/orbit/envelope/utils.py b/py/orbit/envelope/utils.py index bf0ae627..bfb86cf8 100644 --- a/py/orbit/envelope/utils.py +++ b/py/orbit/envelope/utils.py @@ -94,4 +94,4 @@ def bunch_to_numpy(bunch: Bunch) -> np.ndarray: x = np.zeros((bunch.getSize(), 6)) for i in range(bunch.getSize()): x[i, :] = [bunch.x(i), bunch.xp(i), bunch.y(i), bunch.yp(i), bunch.z(i), bunch.dE(i)] - return x \ No newline at end of file + return x From a7ae6c2a76b314b59d956e86230c0bb9775e3508 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 21:59:09 -0400 Subject: [PATCH 25/34] Formatting --- examples/Envelope/bench_danilov.py | 1 + examples/Envelope/bench_kv.py | 4 ++-- examples/Envelope/match_danilov.py | 2 +- examples/Envelope/match_kv.py | 2 +- examples/Envelope/plot_kv.py | 2 +- examples/Envelope/utils.py | 2 +- 6 files changed, 7 insertions(+), 6 deletions(-) diff --git a/examples/Envelope/bench_danilov.py b/examples/Envelope/bench_danilov.py index 79f0aa07..bc9a347f 100644 --- a/examples/Envelope/bench_danilov.py +++ b/examples/Envelope/bench_danilov.py @@ -1,4 +1,5 @@ """Benchmark Danilov envelope tracker vs. PIC.""" + import argparse import copy import os diff --git a/examples/Envelope/bench_kv.py b/examples/Envelope/bench_kv.py index 70c9db43..09b1a963 100644 --- a/examples/Envelope/bench_kv.py +++ b/examples/Envelope/bench_kv.py @@ -35,7 +35,7 @@ parser = argparse.ArgumentParser() parser.add_argument("--phase-adv-x", type=float, default=85.0) parser.add_argument("--phase-adv-y", type=float, default=85.0) -parser.add_argument("--intensity", type=float, default=50.0e+14) +parser.add_argument("--intensity", type=float, default=50.0e14) parser.add_argument("--eps_x", type=float, default=10.00e-06) parser.add_argument("--eps_y", type=float, default=10.00e-06) parser.add_argument("--max-part-length", type=float, default=0.1) @@ -157,4 +157,4 @@ filename = "fig_benchmark_rms.png" filename = os.path.join(output_dir, filename) plt.savefig(filename, dpi=300) -plt.show() \ No newline at end of file +plt.show() diff --git a/examples/Envelope/match_danilov.py b/examples/Envelope/match_danilov.py index f5118766..8bf9047b 100644 --- a/examples/Envelope/match_danilov.py +++ b/examples/Envelope/match_danilov.py @@ -109,4 +109,4 @@ filename = "fig_match.png" filename = os.path.join(output_dir, filename) plt.savefig(filename, dpi=300) -plt.show() \ No newline at end of file +plt.show() diff --git a/examples/Envelope/match_kv.py b/examples/Envelope/match_kv.py index 20c2f25f..1950ea1f 100644 --- a/examples/Envelope/match_kv.py +++ b/examples/Envelope/match_kv.py @@ -100,4 +100,4 @@ filename = "fig_match_rms.png" filename = os.path.join(output_dir, filename) plt.savefig(filename, dpi=300) -plt.show() \ No newline at end of file +plt.show() diff --git a/examples/Envelope/plot_kv.py b/examples/Envelope/plot_kv.py index 815c89e5..c6258d9d 100644 --- a/examples/Envelope/plot_kv.py +++ b/examples/Envelope/plot_kv.py @@ -27,4 +27,4 @@ for ax in axs.flat: ax.set_xticks([]) ax.set_yticks([]) -plt.show() \ No newline at end of file +plt.show() diff --git a/examples/Envelope/utils.py b/examples/Envelope/utils.py index b9af88c6..88a7fa6f 100644 --- a/examples/Envelope/utils.py +++ b/examples/Envelope/utils.py @@ -267,4 +267,4 @@ def __call__(self, params_dict: dict) -> None: message += "s={:0.3f} ".format(self.history["s"][-1]) message += "xrms={:0.3f} ".format(self.history["xrms"][-1] * 1000.0) message += "yrms={:0.3f} ".format(self.history["yrms"][-1] * 1000.0) - print(message) \ No newline at end of file + print(message) From 26f739ca80324a9afc4979286b0a4af1ca39d781 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 22:22:02 -0400 Subject: [PATCH 26/34] Return envelope in tracker function --- examples/Envelope/bench_kv.py | 4 ++-- examples/Envelope/match_kv.py | 4 ++-- examples/Envelope/utils.py | 2 +- py/orbit/envelope/kv.py | 34 +++++++++++++++++++++++++++++++--- 4 files changed, 36 insertions(+), 8 deletions(-) diff --git a/examples/Envelope/bench_kv.py b/examples/Envelope/bench_kv.py index 09b1a963..f456d78c 100644 --- a/examples/Envelope/bench_kv.py +++ b/examples/Envelope/bench_kv.py @@ -86,7 +86,7 @@ histories = {} envelope = envelope_init.copy() -history = tracker.track(envelope, history=True, periods=args.periods) +envelope, history = tracker.track(envelope, history=True, periods=args.periods) histories["envelope"] = copy.deepcopy(history) @@ -116,7 +116,7 @@ for periods in range(args.periods): lattice.trackBunch(bunch, actionContainer=action_container) -history = monitor.package_history() +history = monitor.get_history() histories["bunch"] = copy.deepcopy(history) diff --git a/examples/Envelope/match_kv.py b/examples/Envelope/match_kv.py index 1950ea1f..8c4306b9 100644 --- a/examples/Envelope/match_kv.py +++ b/examples/Envelope/match_kv.py @@ -82,8 +82,8 @@ # Plot results bunch # -------------------------------------------------------------------------------------- -history_unmatched = tracker.track(envelope_unmatched, periods=args.periods, history=True) -history = tracker.track(envelope, periods=args.periods, history=True) +_, history = tracker.track(envelope, periods=args.periods, history=True) +_, history_unmatched = tracker.track(envelope_unmatched, periods=args.periods, history=True) figwidth = 4.0 * args.periods figwidth = min(figwidth, 10.0) diff --git a/examples/Envelope/utils.py b/examples/Envelope/utils.py index 88a7fa6f..500a8737 100644 --- a/examples/Envelope/utils.py +++ b/examples/Envelope/utils.py @@ -228,7 +228,7 @@ def __init__(self, verbose: int = 1) -> None: ]: self.history[key] = [] - def package_history(self) -> None: + def get_history(self) -> None: history = copy.deepcopy(self.history) for key in history: history[key] = np.array(history[key]) diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index f18ca7d3..a162dd70 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -239,7 +239,7 @@ def __init__(self, verbose: int = 0) -> None: ]: self.history[key] = [] - def package(self) -> None: + def get_history(self) -> None: history = copy.deepcopy(self.history) for key in history: history[key] = np.array(history[key]) @@ -328,15 +328,43 @@ def track( action_container.addAction(monitor, AccActionsContainer.ENTRANCE) action_container.addAction(monitor, AccActionsContainer.EXIT) - bunch = envelope.to_bunch() + bunch = envelope.to_bunch() for period in range(periods): self.lattice.trackBunch(bunch, actionContainer=action_container) envelope.from_bunch(bunch) if history: - return monitor.package() + history = monitor.get_history() + return (envelope, history) + + return envelope + + def track_particles(self, envelope: KVEnvelope, particles: np.ndarray = None) -> np.ndarray: + """Track test particles through the lattice.""" + self.update_nodes(envelope) + + bunch = envelope.to_bunch() + for i in range(particles.shape[0]): + bunch.addParticle(*particles[i]) + + self.lattice.trackBunch(bunch, actionContainer=action_container) + + envelope.from_bunch(bunch) + particles_out = [] + for i in range(1, bunch.getSize()): + x = bunch.x(i) + y = bunch.y(i) + z = bunch.z(i) + xp = bunch.xp(i) + yp = bunch.yp(i) + dE = bunch.dE(i) + particles_out.append([x, xp, y, yp, z, dE]) + particles_out = np.array(particles_out) + + return (envelope, particles_out) + def transfer_matrix(self, envelope: KVEnvelope) -> np.ndarray: bunch = envelope.to_bunch(size=0, env=True) From 5a3391491094374eb2f11288b14f3adbe4542940 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 23:52:02 -0400 Subject: [PATCH 27/34] Fix test particle calculation for KV envelope and add benchmark Benchmark sets macrosize=0 in PIC calculation --- examples/Envelope/bench_kv_particle.py | 212 +++++++++++++++++++++++++ examples/Envelope/utils.py | 14 ++ py/orbit/envelope/danilov.py | 13 +- py/orbit/envelope/kv.py | 5 +- src/envelope/KVEnvelopeTracker.cc | 38 +++-- 5 files changed, 256 insertions(+), 26 deletions(-) create mode 100644 examples/Envelope/bench_kv_particle.py diff --git a/examples/Envelope/bench_kv_particle.py b/examples/Envelope/bench_kv_particle.py new file mode 100644 index 00000000..3561614a --- /dev/null +++ b/examples/Envelope/bench_kv_particle.py @@ -0,0 +1,212 @@ +"""Benchmark KV envelope tracker vs. PIC for test particles.""" + +import argparse +import copy +import os +import pathlib +from pprint import pprint + +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.patches as patches +from tqdm import tqdm +from tqdm import trange + +from orbit.core import orbit_mpi +from orbit.core.bunch import Bunch +from orbit.core.bunch import BunchTwissAnalysis +from orbit.core.spacecharge import SpaceChargeCalc2p5D +from orbit.envelope import KVEnvelope +from orbit.envelope import KVEnvelopeTracker +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.lattice import AccActionsContainer +from orbit.space_charge.sc2p5d import SC2p5D_AccNode +from orbit.space_charge.sc2p5d import setSC2p5DAccNodes +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.utils.consts import mass_proton + +from utils import make_fodo_lattice +from utils import BunchMonitor +from utils import rms_ellipse_params + +plt.style.use("style.mplstyle") + + +# Parse arguments +# -------------------------------------------------------------------------------------- + +parser = argparse.ArgumentParser() +parser.add_argument("--phase-adv", type=float, default=100.0) +parser.add_argument("--intensity", type=float, default=10.0e14) +parser.add_argument("--eps_x", type=float, default=10.00e-06) +parser.add_argument("--eps_y", type=float, default=10.00e-06) +parser.add_argument("--max-part-length", type=float, default=0.1) +parser.add_argument("--mismatch", type=float, default=0.0) +parser.add_argument("--periods", type=int, default=50) +args = parser.parse_args() + + +# Setup +# -------------------------------------------------------------------------------------- + +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + +# Set up simulation +# -------------------------------------------------------------------------------------- + +envelope = KVEnvelope( + eps_x=args.eps_x, + eps_y=args.eps_y, + mass=mass_proton, + kin_energy=1.000, + line_density=(args.intensity / 100.0), + length=100.0, + params=None, +) + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv), + phase_adv_y=np.radians(args.phase_adv), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +tracker = KVEnvelopeTracker(lattice, path_length_max=args.max_part_length) +tracker.match_zero_sc(envelope) +tracker.match(envelope, verbose=2) +envelope_init = envelope.copy() + + +# Set test particle coordinates +# -------------------------------------------------------------------------------------- + +test_particles = [ + [0.001, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.005, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.010, 0.0, 0.0, 0.0, 0.0, 0.0], +] +test_particles = np.array(test_particles) + + +# Track envelope with test particles +# -------------------------------------------------------------------------------------- + +particles_tbt = {} +particles_tbt["envelope"] = [] +particles_tbt["bunch"] = [] + +envelope = envelope_init.copy() +particles = test_particles.copy() +for period in range(args.periods): + envelope, particles = tracker.track_particles(envelope, particles=particles) + + cov_matrix = envelope.cov() + cov_matrix *= 1.00e+06 + xrms = np.sqrt(cov_matrix[0, 0]) + yrms = np.sqrt(cov_matrix[2, 2]) + print(f"turn={period} xrms={xrms:0.3f} yrms={yrms:0.3f}") + + particles_tbt["envelope"].append(particles.copy()) + + +# Track bunch +# -------------------------------------------------------------------------------------- + +def set_particle_macrosizes(bunch: Bunch, macrosizes: list[float]) -> Bunch: + bunch.addPartAttr("macrosize") # sets macrosize=0 for all particles + attribute_array_index = 0 + for index in range(bunch.getSize()): + bunch.partAttrValue("macrosize", index, attribute_array_index, macrosizes[index]) + return bunch + + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv), + phase_adv_y=np.radians(args.phase_adv), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +sc_calc = SpaceChargeCalc2p5D(64, 64, 1) +sc_path_length_min = 1.00e-06 +sc_nodes = setSC2p5DAccNodes(lattice, sc_path_length_min, sc_calc) + +bunch_size = 128_000 +bunch = envelope_init.to_bunch(env=False, size=bunch_size) + +for i in range(test_particles.shape[0]): + bunch.addParticle(*test_particles[i]) + +macrosize = args.intensity / bunch_size +macrosizes = macrosize * np.ones(bunch.getSize()) +macrosizes[bunch_size:] = 0 +set_particle_macrosizes(bunch, macrosizes) + +particles_tbt["bunch"] = [] +for period in range(args.periods): + lattice.trackBunch(bunch) + + bunch_calc = BunchTwissAnalysis() + bunch_calc.analyzeBunch(bunch) + xrms = 1000.0 * np.sqrt(bunch_calc.getCorrelation(0, 0)) + yrms = 1000.0 * np.sqrt(bunch_calc.getCorrelation(2, 2)) + print(f"turn={period} xrms={xrms:0.3f} yrms={yrms:0.3f}") + + particles = [] + for i in range(bunch.getSize() - test_particles.shape[0], bunch.getSize()): + particles.append([bunch.x(i), bunch.xp(i), bunch.y(i), bunch.yp(i), bunch.z(i), bunch.dE(i)]) + particles = np.array(particles) + particles_tbt["bunch"].append(particles.copy()) + + +# Analysis +# -------------------------------------------------------------------------------------- + +# Collect data +for key in ["envelope", "bunch"]: + particles_tbt[key] = np.stack(particles_tbt[key]) + +# Plot x-x' +fig, axs = plt.subplots(ncols=2, figsize=(6.0, 3.0), sharex=True, sharey=True) +for ax, key in zip(axs, ["envelope", "bunch"]): + particles = particles_tbt[key] * 1000.0 + for index in range(particles.shape[1]): + ax.scatter(particles[:, index, 0], particles[:, index, 1], s=3) + +cov_matrix = envelope.cov() +cov_matrix = cov_matrix[0:2, 0:2] +cov_matrix = cov_matrix * 1.00e+06 +cx, cy, angle = rms_ellipse_params(cov_matrix) +for ax in axs: + ax.add_patch( + patches.Ellipse( + xy=(0.0, 0.0), + width=(4.0 * cx), + height=(4.0 * cy), + angle=(-np.degrees(angle)), + color="black", + ec="none", + alpha=0.1, + zorder=0, + ) + ) +for ax in axs: + ax.set_xlabel("x [mm]") + ax.set_ylabel("xp [mrad]") + +filename = "fig_benchmark_particles_xxp.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) +plt.show() + + diff --git a/examples/Envelope/utils.py b/examples/Envelope/utils.py index 500a8737..3fd2e0f5 100644 --- a/examples/Envelope/utils.py +++ b/examples/Envelope/utils.py @@ -268,3 +268,17 @@ def __call__(self, params_dict: dict) -> None: message += "xrms={:0.3f} ".format(self.history["xrms"][-1] * 1000.0) message += "yrms={:0.3f} ".format(self.history["yrms"][-1] * 1000.0) print(message) + + +def rms_ellipse_params(cov_matrix: np.ndarray) -> tuple[float, float, float]: + sii = cov_matrix[0, 0] + sjj = cov_matrix[1, 1] + sij = cov_matrix[0, 1] + angle = -0.5 * np.arctan2(2 * sij, sii - sjj) + _sin = np.sin(angle) + _cos = np.cos(angle) + _sin2 = _sin**2 + _cos2 = _cos**2 + c1 = np.sqrt(abs(sii * _cos2 + sjj * _sin2 - 2 * sij * _sin * _cos)) + c2 = np.sqrt(abs(sii * _sin2 + sjj * _cos2 + 2 * sij * _sin * _cos)) + return (c1, c2, angle) diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py index 05e8bbf4..58881d48 100644 --- a/py/orbit/envelope/danilov.py +++ b/py/orbit/envelope/danilov.py @@ -517,7 +517,7 @@ def __init__(self, verbose: int = 0) -> None: ]: self.history[key] = [] - def package(self) -> None: + def get_history(self) -> None: history = copy.deepcopy(self.history) for key in history: history[key] = np.array(history[key]) @@ -622,7 +622,10 @@ def track( envelope.from_bunch(bunch) if history: - return monitor.package() + history = monitor.get_history() + return (envelope, history) + else: + return envelope def transfer_matrix(self, envelope: DanilovEnvelope) -> np.ndarray: bunch = envelope.to_bunch(size=0, env=True) @@ -690,7 +693,11 @@ def match_zero_sc(self, envelope: DanilovEnvelope, method: str = "auto") -> None raise ValueError def match( - self, envelope: DanilovEnvelope, periods: int = 1, method: str = "least_squares", **kwargs + self, + envelope: DanilovEnvelope, + periods: int = 1, + method: str = "least_squares", + **kwargs ) -> None: if envelope.intensity == 0.0: diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index a162dd70..408e72b6 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -340,15 +340,14 @@ def track( return envelope - def track_particles(self, envelope: KVEnvelope, particles: np.ndarray = None) -> np.ndarray: - """Track test particles through the lattice.""" + def track_particles(self, envelope: KVEnvelope, particles: np.ndarray = None) -> tuple[KVEnvelope, np.ndarray]: self.update_nodes(envelope) bunch = envelope.to_bunch() for i in range(particles.shape[0]): bunch.addParticle(*particles[i]) - self.lattice.trackBunch(bunch, actionContainer=action_container) + self.lattice.trackBunch(bunch) envelope.from_bunch(bunch) diff --git a/src/envelope/KVEnvelopeTracker.cc b/src/envelope/KVEnvelopeTracker.cc index 43a47022..4048c071 100644 --- a/src/envelope/KVEnvelopeTracker.cc +++ b/src/envelope/KVEnvelopeTracker.cc @@ -31,59 +31,57 @@ double KVEnvelopeTracker::getEmittanceY() { } void KVEnvelopeTracker::trackBunch(Bunch *bunch, double length) { - // Track envelope + + // Kick envelope double cx = bunch->x(0); double cy = bunch->y(0); - double sc_term = 2.0 * Q / (cx + cy); double eps_x_term = (eps_x * eps_x) / (cx * cx * cx); double eps_y_term = (eps_y * eps_y) / (cy * cy * cy); + double sc_term = 2.0 * Q / (cx + cy); bunch->xp(0) += length * (sc_term + eps_x_term); bunch->yp(0) += length * (sc_term + eps_y_term); - // Track test particles - double cx2 = cx * cx; - double cy2 = cy * cy; - - double x; - double y; + // Kick particles + double x; // particle x + double y; // particle y double x2; double y2; + double delta_xp; // change in x' + double delta_yp; // change in y' + bool inside; // inside x-y ellipse + double cx2 = cx * cx; + double cy2 = cy * cy; double B; double C; double Dx; double Dy; double t1; - double delta_xp; - double delta_yp; - bool inside; - for (int i = 1; i < bunch->getSize(); i++) { x = bunch->x(i); y = bunch->y(i); - + x2 = x * x; y2 = y * y; - inside = ((x2 / cx2) + (y2 / cy2)) <= 1.0; if (inside) { - delta_xp = sc_term * x / cx; - delta_yp = sc_term * y / cy; + delta_xp = length * (sc_term * x / cx); + delta_yp = length * (sc_term * y / cy); } else { // https://arxiv.org/abs/physics/0108040 - // UNTESTED! B = x2 + y2 - cx2 - cy2; C = x2 * cy2 + y2 * cx2 - cx2 * cy2; t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; Dx = pow(cx2 + t1, 0.5); Dy = pow(cy2 + t1, 0.5); - delta_xp = 2.0 * Q * x / (Dx * (Dx + Dy)); - delta_yp = 2.0 * Q * y / (Dy * (Dx + Dy)); + delta_xp = length * (2.0 * Q * x / (Dx * (Dx + Dy))); + delta_yp = length * (2.0 * Q * y / (Dy * (Dx + Dy))); } bunch->xp(i) += delta_xp; bunch->yp(i) += delta_yp; } - } \ No newline at end of file + +} \ No newline at end of file From 451db8155578cdea2e9a0f7bb4ba2b0dea25f7c6 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 23:54:25 -0400 Subject: [PATCH 28/34] Fix test particle tracking in DanilovEnvelopeTracker --- src/envelope/DanilovEnvelopeTracker.cc | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/envelope/DanilovEnvelopeTracker.cc b/src/envelope/DanilovEnvelopeTracker.cc index 7e9fb341..990114c0 100644 --- a/src/envelope/DanilovEnvelopeTracker.cc +++ b/src/envelope/DanilovEnvelopeTracker.cc @@ -95,15 +95,14 @@ void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { if (in_ellipse) { if (cxn > 0.0) { - delta_xpn = factor * xn / cxn; + delta_xpn = length * factor * xn / cxn; } if (cyn > 0.0) { - delta_ypn = factor * yn / cyn; + delta_ypn = length * factor * yn / cyn; } } else { // https://arxiv.org/abs/physics/0108040 - // UNTESTED! B = xn2 + yn2 - cxn2 - cyn2; C = xn2 * cyn2 + yn2 * cxn2 - cxn2 * cyn2; t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; @@ -112,8 +111,8 @@ void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { delta_xpn = 2.0 * Q * xn / (Dx * (Dx + Dy)); delta_ypn = 2.0 * Q * yn / (Dy * (Dx + Dy)); } - delta_xp = +delta_xpn * _cos + delta_ypn * _sin; - delta_yp = -delta_xpn * _sin + delta_ypn * _cos; + delta_xp = length * (+delta_xpn * _cos + delta_ypn * _sin); + delta_yp = length * (-delta_xpn * _sin + delta_ypn * _cos); bunch->xp(i) += delta_xp; bunch->yp(i) += delta_yp; } From 7ae9da560030eb1aa8247a3877fefc5018fb437a Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 23:54:43 -0400 Subject: [PATCH 29/34] Add track_particles to DanilovEnvelopeTracker --- py/orbit/envelope/danilov.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py index 58881d48..3958228d 100644 --- a/py/orbit/envelope/danilov.py +++ b/py/orbit/envelope/danilov.py @@ -627,6 +627,30 @@ def track( else: return envelope + def track_particles(self, envelope: KVEnvelope, particles: np.ndarray = None) -> tuple[KVEnvelope, np.ndarray]: + self.update_nodes(envelope) + + bunch = envelope.to_bunch() + for i in range(particles.shape[0]): + bunch.addParticle(*particles[i]) + + self.lattice.trackBunch(bunch) + + envelope.from_bunch(bunch) + + particles_out = [] + for i in range(2, bunch.getSize()): + x = bunch.x(i) + y = bunch.y(i) + z = bunch.z(i) + xp = bunch.xp(i) + yp = bunch.yp(i) + dE = bunch.dE(i) + particles_out.append([x, xp, y, yp, z, dE]) + particles_out = np.array(particles_out) + + return (envelope, particles_out) + def transfer_matrix(self, envelope: DanilovEnvelope) -> np.ndarray: bunch = envelope.to_bunch(size=0, env=True) From f17b08815109bc56b19761158f5e6948890f12a8 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sun, 21 Sep 2025 00:20:31 -0400 Subject: [PATCH 30/34] Fix DanilovEnvelopeTracker test particle tracking and add benchmark Benchmark successful for particles outside envelope vs. PIC --- examples/Envelope/bench_danilov_particle.py | 212 ++++++++++++++++++++ py/orbit/envelope/danilov.py | 6 +- py/orbit/envelope/kv.py | 2 +- src/envelope/DanilovEnvelopeTracker.cc | 32 +-- 4 files changed, 231 insertions(+), 21 deletions(-) create mode 100644 examples/Envelope/bench_danilov_particle.py diff --git a/examples/Envelope/bench_danilov_particle.py b/examples/Envelope/bench_danilov_particle.py new file mode 100644 index 00000000..8f2d48a3 --- /dev/null +++ b/examples/Envelope/bench_danilov_particle.py @@ -0,0 +1,212 @@ +"""Benchmark Danilov envelope tracker vs. PIC for test particles.""" + +import argparse +import copy +import os +import pathlib +from pprint import pprint + +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.patches as patches +from tqdm import tqdm +from tqdm import trange + +from orbit.core import orbit_mpi +from orbit.core.bunch import Bunch +from orbit.core.bunch import BunchTwissAnalysis +from orbit.core.spacecharge import SpaceChargeCalc2p5D +from orbit.envelope import DanilovEnvelope +from orbit.envelope import DanilovEnvelopeTracker +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.lattice import AccActionsContainer +from orbit.space_charge.sc2p5d import SC2p5D_AccNode +from orbit.space_charge.sc2p5d import setSC2p5DAccNodes +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.utils.consts import mass_proton + +from utils import make_fodo_lattice +from utils import BunchMonitor +from utils import rms_ellipse_params + +plt.style.use("style.mplstyle") + + +# Parse arguments +# -------------------------------------------------------------------------------------- + +parser = argparse.ArgumentParser() +parser.add_argument("--phase-adv", type=float, default=100.0) +parser.add_argument("--intensity", type=float, default=10.0e14) +parser.add_argument("--eps_x", type=float, default=10.00e-06) +parser.add_argument("--eps_y", type=float, default=10.00e-06) +parser.add_argument("--max-part-length", type=float, default=0.1) +parser.add_argument("--mismatch", type=float, default=0.0) +parser.add_argument("--periods", type=int, default=50) +args = parser.parse_args() + + +# Setup +# -------------------------------------------------------------------------------------- + +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + +# Set up simulation +# -------------------------------------------------------------------------------------- + +envelope = DanilovEnvelope( + eps_1=20.00e-06, + eps_2=0.0, + mass=0.938, + kin_energy=1.0, + length=100.0, + line_density=(args.intensity / 100.0), + params=None, +) + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv), + phase_adv_y=np.radians(args.phase_adv), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +tracker = DanilovEnvelopeTracker(lattice, path_length_max=args.max_part_length) +tracker.match_zero_sc(envelope, method="2d") +tracker.match(envelope, method="replace_avg", periods_avg=20, verbose=2) +envelope_init = envelope.copy() + + +# Set test particle coordinates +# -------------------------------------------------------------------------------------- + +test_particles = [ + [0.001, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.005, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.010, 0.0, 0.0, 0.0, 0.0, 0.0], +] +test_particles = np.array(test_particles) + + +# Track envelope with test particles +# -------------------------------------------------------------------------------------- + +particles_tbt = {} +particles_tbt["envelope"] = [] +particles_tbt["bunch"] = [] + +envelope = envelope_init.copy() +particles = test_particles.copy() +for period in range(args.periods): + envelope, particles = tracker.track_particles(envelope, particles=particles) + + cov_matrix = envelope.cov() + cov_matrix *= 1.00e+06 + xrms = np.sqrt(cov_matrix[0, 0]) + yrms = np.sqrt(cov_matrix[2, 2]) + print(f"turn={period} xrms={xrms:0.3f} yrms={yrms:0.3f}") + + particles_tbt["envelope"].append(particles.copy()) + + +# Track bunch +# -------------------------------------------------------------------------------------- + +def set_particle_macrosizes(bunch: Bunch, macrosizes: list[float]) -> Bunch: + bunch.addPartAttr("macrosize") # sets macrosize=0 for all particles + attribute_array_index = 0 + for index in range(bunch.getSize()): + bunch.partAttrValue("macrosize", index, attribute_array_index, macrosizes[index]) + return bunch + + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv), + phase_adv_y=np.radians(args.phase_adv), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +sc_calc = SpaceChargeCalc2p5D(64, 64, 1) +sc_path_length_min = 1.00e-06 +sc_nodes = setSC2p5DAccNodes(lattice, sc_path_length_min, sc_calc) + +bunch_size = 128_000 +bunch = envelope_init.to_bunch(env=False, size=bunch_size) + +for i in range(test_particles.shape[0]): + bunch.addParticle(*test_particles[i]) + +macrosize = args.intensity / bunch_size +macrosizes = macrosize * np.ones(bunch.getSize()) +macrosizes[bunch_size:] = 0 +set_particle_macrosizes(bunch, macrosizes) + +particles_tbt["bunch"] = [] +for period in range(args.periods): + lattice.trackBunch(bunch) + + bunch_calc = BunchTwissAnalysis() + bunch_calc.analyzeBunch(bunch) + xrms = 1000.0 * np.sqrt(bunch_calc.getCorrelation(0, 0)) + yrms = 1000.0 * np.sqrt(bunch_calc.getCorrelation(2, 2)) + print(f"turn={period} xrms={xrms:0.3f} yrms={yrms:0.3f}") + + particles = [] + for i in range(bunch.getSize() - test_particles.shape[0], bunch.getSize()): + particles.append([bunch.x(i), bunch.xp(i), bunch.y(i), bunch.yp(i), bunch.z(i), bunch.dE(i)]) + particles = np.array(particles) + particles_tbt["bunch"].append(particles.copy()) + + +# Analysis +# -------------------------------------------------------------------------------------- + +# Collect data +for key in ["envelope", "bunch"]: + particles_tbt[key] = np.stack(particles_tbt[key]) + +# Plot x-x' +fig, axs = plt.subplots(ncols=2, figsize=(6.0, 3.0), sharex=True, sharey=True) +for ax, key in zip(axs, ["envelope", "bunch"]): + particles = particles_tbt[key] * 1000.0 + for index in range(particles.shape[1]): + ax.scatter(particles[:, index, 0], particles[:, index, 1], s=3) + +cov_matrix = envelope.cov() +cov_matrix = cov_matrix[0:2, 0:2] +cov_matrix = cov_matrix * 1.00e+06 +cx, cy, angle = rms_ellipse_params(cov_matrix) +for ax in axs: + ax.add_patch( + patches.Ellipse( + xy=(0.0, 0.0), + width=(4.0 * cx), + height=(4.0 * cy), + angle=(-np.degrees(angle)), + color="black", + ec="none", + alpha=0.1, + zorder=0, + ) + ) +for ax in axs: + ax.set_xlabel("x [mm]") + ax.set_ylabel("xp [mrad]") + +filename = "fig_benchmark_particles_xxp.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) +plt.show() + + diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py index 3958228d..9f8398e8 100644 --- a/py/orbit/envelope/danilov.py +++ b/py/orbit/envelope/danilov.py @@ -442,7 +442,6 @@ def sample(self, size: int) -> np.ndarray: A = np.sqrt(np.diag([self.eps_1, self.eps_1, self.eps_2, self.eps_2])) V = self.unnorm_matrix(method="4d") - print(V) X = np.matmul(X, A.T) X = np.matmul(X, V.T) @@ -477,7 +476,6 @@ def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: particles = np.zeros((size, 6)) particles[:, :4] = self.sample(size) particles[:, 4] = self.length * np.random.uniform(-0.5, 0.5, size=size) - print(np.std(particles, axis=0)) for i in range(size): bunch.addParticle(*particles[i, :]) @@ -605,7 +603,7 @@ def track( envelope: DanilovEnvelope, periods: int = 1, history: bool = False, - ) -> None | dict[str, np.ndarray]: + ) -> DanilovEnvelope: self.update_nodes(envelope) @@ -627,7 +625,7 @@ def track( else: return envelope - def track_particles(self, envelope: KVEnvelope, particles: np.ndarray = None) -> tuple[KVEnvelope, np.ndarray]: + def track_particles(self, envelope: DanilovEnvelope, particles: np.ndarray = None) -> tuple[DanilovEnvelope, np.ndarray]: self.update_nodes(envelope) bunch = envelope.to_bunch() diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index 408e72b6..454fa752 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -319,7 +319,7 @@ def track( envelope: KVEnvelope, periods: int = 1, history: bool = False, - ) -> None | dict[str, np.ndarray]: + ) -> KVEnvelope: self.update_nodes(envelope) monitor = KVEnvelopeMonitor() diff --git a/src/envelope/DanilovEnvelopeTracker.cc b/src/envelope/DanilovEnvelopeTracker.cc index 990114c0..f08f95c9 100644 --- a/src/envelope/DanilovEnvelopeTracker.cc +++ b/src/envelope/DanilovEnvelopeTracker.cc @@ -37,20 +37,20 @@ void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { double cxn = sqrt(abs(cov_xx * cos2 + cov_yy * sin2 - 2.0 * cov_xy * sin_cos)); double cyn = sqrt(abs(cov_xx * sin2 + cov_yy * cos2 + 2.0 * cov_xy * sin_cos)); - double factor = length * (2.0 * Q / (cxn + cyn)); + double sc_term = (2.0 * Q / (cxn + cyn)); // Track envelope if (cxn > 0.0) { - bunch->xp(0) += factor * (a * cos2 - e * sin_cos) / cxn; - bunch->xp(1) += factor * (b * cos2 - f * sin_cos) / cxn; - bunch->yp(0) += factor * (e * sin2 - a * sin_cos) / cxn; - bunch->yp(1) += factor * (f * sin2 - b * sin_cos) / cxn; + bunch->xp(0) += length * sc_term * (a * cos2 - e * sin_cos) / cxn; + bunch->xp(1) += length * sc_term * (b * cos2 - f * sin_cos) / cxn; + bunch->yp(0) += length * sc_term * (e * sin2 - a * sin_cos) / cxn; + bunch->yp(1) += length * sc_term * (f * sin2 - b * sin_cos) / cxn; } if (cyn > 0.0) { - bunch->xp(0) += factor * (a * sin2 + e * sin_cos) / cyn; - bunch->xp(1) += factor * (b * sin2 + f * sin_cos) / cyn; - bunch->yp(0) += factor * (e * cos2 + a * sin_cos) / cyn; - bunch->yp(1) += factor * (f * cos2 + b * sin_cos) / cyn; + bunch->xp(0) += length * sc_term * (a * sin2 + e * sin_cos) / cyn; + bunch->xp(1) += length * sc_term * (b * sin2 + f * sin_cos) / cyn; + bunch->yp(0) += length * sc_term * (e * cos2 + a * sin_cos) / cyn; + bunch->yp(1) += length * sc_term * (f * cos2 + b * sin_cos) / cyn; } // Track test particles @@ -95,10 +95,10 @@ void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { if (in_ellipse) { if (cxn > 0.0) { - delta_xpn = length * factor * xn / cxn; + delta_xpn = length * sc_term * xn / cxn; } if (cyn > 0.0) { - delta_ypn = length * factor * yn / cyn; + delta_ypn = length * sc_term * yn / cyn; } } else { @@ -108,12 +108,12 @@ void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; Dx = pow(cxn2 + t1, 0.5); Dy = pow(cyn2 + t1, 0.5); - delta_xpn = 2.0 * Q * xn / (Dx * (Dx + Dy)); - delta_ypn = 2.0 * Q * yn / (Dy * (Dx + Dy)); + delta_xpn = length * 2.0 * Q * xn / (Dx * (Dx + Dy)); + delta_ypn = length * 2.0 * Q * yn / (Dy * (Dx + Dy)); } - delta_xp = length * (+delta_xpn * _cos + delta_ypn * _sin); - delta_yp = length * (-delta_xpn * _sin + delta_ypn * _cos); + delta_xp = (+delta_xpn * _cos + delta_ypn * _sin); + delta_yp = (-delta_xpn * _sin + delta_ypn * _cos); bunch->xp(i) += delta_xp; bunch->yp(i) += delta_yp; } -} +} \ No newline at end of file From fe8553a217247786535835adf13ca668a641abd3 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sun, 21 Sep 2025 13:56:09 -0400 Subject: [PATCH 31/34] Clean up envelope tracker c++ code --- src/envelope/DanilovEnvelopeTracker.cc | 197 +++++++--------- src/envelope/DanilovEnvelopeTracker.hh | 20 +- src/envelope/KVEnvelopeTracker.cc | 91 +++---- src/envelope/KVEnvelopeTracker.hh | 32 +-- src/envelope/wrap_danilov_envelope_tracker.cc | 161 +++++++------ src/envelope/wrap_envelope.cc | 22 +- src/envelope/wrap_envelope.hh | 2 +- src/envelope/wrap_kv_envelope_tracker.cc | 223 +++++++++--------- 8 files changed, 358 insertions(+), 390 deletions(-) diff --git a/src/envelope/DanilovEnvelopeTracker.cc b/src/envelope/DanilovEnvelopeTracker.cc index f08f95c9..1ec3a228 100644 --- a/src/envelope/DanilovEnvelopeTracker.cc +++ b/src/envelope/DanilovEnvelopeTracker.cc @@ -1,119 +1,104 @@ #include "DanilovEnvelopeTracker.hh" DanilovEnvelopeTracker::DanilovEnvelopeTracker(double perveance) : CppPyWrapper(NULL) { - Q = perveance; + Q = perveance; } -void DanilovEnvelopeTracker::setPerveance(double perveance) { - Q = perveance; +void DanilovEnvelopeTracker::setPerveance(double perveance) { + Q = perveance; } -double DanilovEnvelopeTracker::getPerveance() { - return Q; +double DanilovEnvelopeTracker::getPerveance() { + return Q; } void DanilovEnvelopeTracker::trackBunch(Bunch *bunch, double length) { - // Compute ellipse size and orientation. - double a = bunch->x(0); - double b = bunch->x(1); - double e = bunch->y(0); - double f = bunch->y(1); - double ap = bunch->xp(0); - double bp = bunch->xp(1); - double ep = bunch->yp(0); - double fp = bunch->yp(1); - - double cov_xx = a * a + b * b; // 4 * - double cov_yy = e * e + f * f; // 4 * - double cov_xy = a * e + b * f; // 4 * - - double phi = -0.5 * atan2(2.0 * cov_xy, cov_xx - cov_yy); - - double _cos = cos(phi); - double _sin = sin(phi); - double cos2 = _cos * _cos; - double sin2 = _sin * _sin; - double sin_cos = _sin * _cos; - - double cxn = sqrt(abs(cov_xx * cos2 + cov_yy * sin2 - 2.0 * cov_xy * sin_cos)); - double cyn = sqrt(abs(cov_xx * sin2 + cov_yy * cos2 + 2.0 * cov_xy * sin_cos)); - double sc_term = (2.0 * Q / (cxn + cyn)); - - // Track envelope - if (cxn > 0.0) { - bunch->xp(0) += length * sc_term * (a * cos2 - e * sin_cos) / cxn; - bunch->xp(1) += length * sc_term * (b * cos2 - f * sin_cos) / cxn; - bunch->yp(0) += length * sc_term * (e * sin2 - a * sin_cos) / cxn; - bunch->yp(1) += length * sc_term * (f * sin2 - b * sin_cos) / cxn; - } - if (cyn > 0.0) { - bunch->xp(0) += length * sc_term * (a * sin2 + e * sin_cos) / cyn; - bunch->xp(1) += length * sc_term * (b * sin2 + f * sin_cos) / cyn; - bunch->yp(0) += length * sc_term * (e * cos2 + a * sin_cos) / cyn; - bunch->yp(1) += length * sc_term * (f * cos2 + b * sin_cos) / cyn; - } - - // Track test particles - double cxn2 = cxn * cxn; - double cyn2 = cyn * cyn; - double x; - double y; - double x2; - double y2; - - double xn; - double yn; - double xn2; - double yn2; - - double t1; - double B; - double C; - double Dx; - double Dy; - - double delta_xp; - double delta_yp; - double delta_xpn; - double delta_ypn; - bool in_ellipse; - - for (int i = 2; i < bunch->getSize(); i++) { - x = bunch->x(i); - y = bunch->y(i); - - x2 = x * x; - y2 = y * y; - - xn = x * _cos - y * _sin; - yn = x * _sin + y * _cos; - - xn2 = xn * xn; - yn2 = yn * yn; - - in_ellipse = ((xn2 / cxn2) + (yn2 / cyn2)) <= 1.0; + // Compute ellipse size and orientation. + // ----------------------------------------------------------------------------------- + + // Get envelope parameters from first two bunch particles. + double a = bunch->x(0); + double b = bunch->x(1); + double e = bunch->y(0); + double f = bunch->y(1); + + // Compute covariance matrix in x-y plane + double cov_xx = a * a + b * b; // 4 * + double cov_yy = e * e + f * f; // 4 * + double cov_xy = a * e + b * f; // 4 * + + // Compute tilt angle phi in x-y plane (below x axis). + double phi = -0.5 * atan2(2.0 * cov_xy, cov_xx - cov_yy); + + // Store sin(phi) and cos(phi). + double cs = cos(phi); + double sn = sin(phi); + double cs2 = cs * cs; + double sn2 = sn * sn; + double sn_cs = sn * cs; + + // Compute ellipse radii cu and cv in upright frame. + double cu = sqrt(abs(cov_xx * cs2 + cov_yy * sn2 - 2.0 * cov_xy * sn_cs)); + double cv = sqrt(abs(cov_xx * sn2 + cov_yy * cs2 + 2.0 * cov_xy * sn_cs)); + double cu2 = cu * cu; + double cv2 = cv * cv; + + // Kick envelope + // ----------------------------------------------------------------------------------- + + double sc_term = (2.0 * Q / (cu + cv)); + if (cu > 0.0) { + bunch->xp(0) += length * sc_term * (a * cs2 - e * sn_cs) / cu; + bunch->xp(1) += length * sc_term * (b * cs2 - f * sn_cs) / cu; + bunch->yp(0) += length * sc_term * (e * sn2 - a * sn_cs) / cu; + bunch->yp(1) += length * sc_term * (f * sn2 - b * sn_cs) / cu; + } + if (cv > 0.0) { + bunch->xp(0) += length * sc_term * (a * sn2 + e * sn_cs) / cv; + bunch->xp(1) += length * sc_term * (b * sn2 + f * sn_cs) / cv; + bunch->yp(0) += length * sc_term * (e * cs2 + a * sn_cs) / cv; + bunch->yp(1) += length * sc_term * (f * cs2 + b * sn_cs) / cv; + } - if (in_ellipse) { - if (cxn > 0.0) { - delta_xpn = length * sc_term * xn / cxn; - } - if (cyn > 0.0) { - delta_ypn = length * sc_term * yn / cyn; - } - } - else { - // https://arxiv.org/abs/physics/0108040 - B = xn2 + yn2 - cxn2 - cyn2; - C = xn2 * cyn2 + yn2 * cxn2 - cxn2 * cyn2; - t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; - Dx = pow(cxn2 + t1, 0.5); - Dy = pow(cyn2 + t1, 0.5); - delta_xpn = length * 2.0 * Q * xn / (Dx * (Dx + Dy)); - delta_ypn = length * 2.0 * Q * yn / (Dy * (Dx + Dy)); + // Kick particles + // ----------------------------------------------------------------------------------- + + for (int i = 2; i < bunch->getSize(); i++) { + // Collect particle coordinates. + double x = bunch->x(i); + double y = bunch->y(i); + double u = x * cs - y * sn; + double v = x * sn + y * cs; + + // Check if particle is inside beam ellipse. + double u2 = u * u; + double v2 = v * v; + bool in_ellipse = ((u2 / cu2) + (v2 / cv2)) <= 1.0; + + // Update momentum. + double delta_up = 0.0; + double delta_vp = 0.0; + + if (in_ellipse) { + if (cu > 0.0) { + delta_up = length * sc_term * u / cu; + } + if (cv > 0.0) { + delta_vp = length * sc_term * v / cv; + } + } + else { + // https://arxiv.org/abs/physics/0108040 + double B = u2 + v2 - cu2 - cv2; + double C = u2 * cv2 + v2 * cu2 - cu2 * cv2; + double t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; + double Dx = pow(cu2 + t1, 0.5); + double Dy = pow(cv2 + t1, 0.5); + delta_up = length * 2.0 * Q * u / (Dx * (Dx + Dy)); + delta_vp = length * 2.0 * Q * v / (Dy * (Dx + Dy)); + } + + bunch->xp(i) += (+delta_up * cs + delta_vp * sn); + bunch->yp(i) += (-delta_up * sn + delta_vp * cs); } - delta_xp = (+delta_xpn * _cos + delta_ypn * _sin); - delta_yp = (-delta_xpn * _sin + delta_ypn * _cos); - bunch->xp(i) += delta_xp; - bunch->yp(i) += delta_yp; - } } \ No newline at end of file diff --git a/src/envelope/DanilovEnvelopeTracker.hh b/src/envelope/DanilovEnvelopeTracker.hh index 9758931d..2a81ec23 100644 --- a/src/envelope/DanilovEnvelopeTracker.hh +++ b/src/envelope/DanilovEnvelopeTracker.hh @@ -18,19 +18,19 @@ using namespace std; References ---------- - [1] V. Danilov, S. Cousineau, S. Henderson, and J. Holmes, "Self-consistent time - dependent two dimensional and three dimensional space charge distributions with - linear force", PPRAB 6, 74–85 (2003). + [1] V. Danilov, S. Cousineau, S. Henderson, and J. Holmes, "Self-consistent + time dependent two dimensional and three dimensional space charge distributions + with linear force", PPRAB 6, 74–85 (2003). */ class DanilovEnvelopeTracker : public OrbitUtils::CppPyWrapper { -public: - DanilovEnvelopeTracker(double perveanceQ); - void trackBunch(Bunch *bunch, double length); - void setPerveance(double perveance); - double getPerveance(); + public: + DanilovEnvelopeTracker(double perveanceQ); + void trackBunch(Bunch *bunch, double length); + void setPerveance(double perveance); + double getPerveance(); -private: - double Q; // beam perveance + private: + double Q; // beam perveance }; #endif \ No newline at end of file diff --git a/src/envelope/KVEnvelopeTracker.cc b/src/envelope/KVEnvelopeTracker.cc index 4048c071..5a8e621c 100644 --- a/src/envelope/KVEnvelopeTracker.cc +++ b/src/envelope/KVEnvelopeTracker.cc @@ -1,40 +1,43 @@ #include "KVEnvelopeTracker.hh" -KVEnvelopeTracker::KVEnvelopeTracker(double perveance, double emittance_x, double emittance_y) : CppPyWrapper(NULL) { - Q = perveance; - eps_x = emittance_x; - eps_y = emittance_y; +KVEnvelopeTracker::KVEnvelopeTracker(double perveance, double emittance_x, double emittance_y): CppPyWrapper(NULL) { + Q = perveance; + eps_x = emittance_x; + eps_y = emittance_y; } -void KVEnvelopeTracker::setPerveance(double perveance) { - Q = perveance; +void KVEnvelopeTracker::setPerveance(double perveance) { + Q = perveance; } -void KVEnvelopeTracker::setEmittanceX(double emittance) { - eps_x = emittance; +void KVEnvelopeTracker::setEmittanceX(double emittance) { + eps_x = emittance; } -void KVEnvelopeTracker::setEmittanceY(double emittance) { - eps_y = emittance; +void KVEnvelopeTracker::setEmittanceY(double emittance) { + eps_y = emittance; } -double KVEnvelopeTracker::getPerveance() { - return Q; +double KVEnvelopeTracker::getPerveance() { + return Q; } -double KVEnvelopeTracker::getEmittanceX() { - return eps_x; +double KVEnvelopeTracker::getEmittanceX() { + return eps_x; } -double KVEnvelopeTracker::getEmittanceY() { - return eps_y; +double KVEnvelopeTracker::getEmittanceY() { + return eps_y; } void KVEnvelopeTracker::trackBunch(Bunch *bunch, double length) { - - // Kick envelope + // Get envelope parameters double cx = bunch->x(0); double cy = bunch->y(0); + double cx2 = cx * cx; + double cy2 = cy * cy; + + // Kick envelope double eps_x_term = (eps_x * eps_x) / (cx * cx * cx); double eps_y_term = (eps_y * eps_y) / (cy * cy * cy); double sc_term = 2.0 * Q / (cx + cy); @@ -42,46 +45,28 @@ void KVEnvelopeTracker::trackBunch(Bunch *bunch, double length) { bunch->yp(0) += length * (sc_term + eps_y_term); // Kick particles - double x; // particle x - double y; // particle y - double x2; - double y2; - double delta_xp; // change in x' - double delta_yp; // change in y' - bool inside; // inside x-y ellipse - - double cx2 = cx * cx; - double cy2 = cy * cy; - double B; - double C; - double Dx; - double Dy; - double t1; - for (int i = 1; i < bunch->getSize(); i++) { - x = bunch->x(i); - y = bunch->y(i); - - x2 = x * x; - y2 = y * y; - inside = ((x2 / cx2) + (y2 / cy2)) <= 1.0; + // Check if particle is inside beam ellipse. + double x = bunch->x(i); + double y = bunch->y(i); + double x2 = x * x; + double y2 = y * y; + bool in_ellipse = ((x2 / cx2) + (y2 / cy2)) <= 1.0; - if (inside) { - delta_xp = length * (sc_term * x / cx); - delta_yp = length * (sc_term * y / cy); + // Update momentum coordinates + if (in_ellipse) { + bunch->xp(i) += length * sc_term * (x / cx); + bunch->yp(i) += length * sc_term * (y / cy); } else { // https://arxiv.org/abs/physics/0108040 - B = x2 + y2 - cx2 - cy2; - C = x2 * cy2 + y2 * cx2 - cx2 * cy2; - t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; - Dx = pow(cx2 + t1, 0.5); - Dy = pow(cy2 + t1, 0.5); - delta_xp = length * (2.0 * Q * x / (Dx * (Dx + Dy))); - delta_yp = length * (2.0 * Q * y / (Dy * (Dx + Dy))); + double B = x2 + y2 - cx2 - cy2; + double C = x2 * cy2 + y2 * cx2 - cx2 * cy2; + double t1 = pow(0.25 * B * B + C, 0.5) + 0.5 * B; + double Dx = pow(cx2 + t1, 0.5); + double Dy = pow(cy2 + t1, 0.5); + bunch->xp(i) += length * (2.0 * Q * x / (Dx * (Dx + Dy))); + bunch->yp(i) += length * (2.0 * Q * y / (Dy * (Dx + Dy))); } - bunch->xp(i) += delta_xp; - bunch->yp(i) += delta_yp; } - } \ No newline at end of file diff --git a/src/envelope/KVEnvelopeTracker.hh b/src/envelope/KVEnvelopeTracker.hh index c8c28e62..ffbd3805 100644 --- a/src/envelope/KVEnvelopeTracker.hh +++ b/src/envelope/KVEnvelopeTracker.hh @@ -8,27 +8,27 @@ using namespace std; /** Envelope solver for upright KV distribution in uncoupled lattice. -The first particle in the bunch is used to track the -envelope parameters. The envelope parameters are use to apply space charge -kicks to the other particles in the bunch. +The first particle in the bunch is used to track the envelope parameters. +The envelope parameters are use to apply space charge kicks to the other +particles in the bunch. This class does not yet handle boudary conditions or dispersion. */ class KVEnvelopeTracker : public OrbitUtils::CppPyWrapper { -public: - KVEnvelopeTracker(double perveance, double emittance_x, double emittance_y); - void trackBunch(Bunch *bunch, double length); - void setPerveance(double perveance); - void setEmittanceX(double emittance); - void setEmittanceY(double emittance); - double getPerveance(); - double getEmittanceX(); - double getEmittanceY(); + public: + KVEnvelopeTracker(double perveance, double emittance_x, double emittance_y); + void trackBunch(Bunch *bunch, double length); + void setPerveance(double perveance); + void setEmittanceX(double emittance); + void setEmittanceY(double emittance); + double getPerveance(); + double getEmittanceX(); + double getEmittanceY(); -private: - double Q; // beam perveance - double eps_x; // (4 * sqrt( - )) - double eps_y; // (4 * sqrt( - )) + private: + double Q; // beam perveance + double eps_x; // (4 * sqrt( - )) + double eps_y; // (4 * sqrt( - )) }; #endif \ No newline at end of file diff --git a/src/envelope/wrap_danilov_envelope_tracker.cc b/src/envelope/wrap_danilov_envelope_tracker.cc index bb0c76d5..0cba286d 100644 --- a/src/envelope/wrap_danilov_envelope_tracker.cc +++ b/src/envelope/wrap_danilov_envelope_tracker.cc @@ -5,8 +5,8 @@ #include "DanilovEnvelopeTracker.hh" #include "wrap_bunch.hh" -#include "wrap_envelope.hh" #include "wrap_danilov_envelope_tracker.hh" +#include "wrap_envelope.hh" namespace wrap_envelope { @@ -17,134 +17,133 @@ extern "C" { // Constructor for Python class wrapping DanilovEnvelopeTracker instance. // It never will be called directly. static PyObject *DanilovEnvelopeTracker_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - pyORBIT_Object *self; - self = (pyORBIT_Object *)type->tp_alloc(type, 0); - self->cpp_obj = NULL; - return (PyObject *)self; + pyORBIT_Object *self; + self = (pyORBIT_Object *)type->tp_alloc(type, 0); + self->cpp_obj = NULL; + return (PyObject *)self; } // Initialization of Python DanilovEnvelopeTracker class. // This is implementation of the __init__ method. static int DanilovEnvelopeTracker_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { - double perveance = 0.0; - self->cpp_obj = new DanilovEnvelopeTracker(perveance); - ((DanilovEnvelopeTracker *)self->cpp_obj)->setPyWrapper((PyObject *)self); - return 0; + double perveance = 0.0; + self->cpp_obj = new DanilovEnvelopeTracker(perveance); + ((DanilovEnvelopeTracker *)self->cpp_obj)->setPyWrapper((PyObject *)self); + return 0; } // Method: trackBunch(Bunch* bunch, double length) static PyObject *DanilovEnvelopeTracker_trackBunch(PyObject *self, PyObject *args) { - pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; - DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; - PyObject *pyBunch; - double length; - if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { - ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - trackBunch(Bunch* bunch, double length) - parameters are needed."); - } - PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); - if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { - ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); - } - Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; - cpp_DanilovEnvelopeTracker->trackBunch(cpp_bunch, length); - Py_INCREF(Py_None); - return Py_None; + pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; + PyObject *pyBunch; + double length; + if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { + ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - trackBunch(Bunch* bunch, double length) - parameters are needed."); + } + PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); + if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { + ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); + } + Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; + cpp_DanilovEnvelopeTracker->trackBunch(cpp_bunch, length); + Py_INCREF(Py_None); + return Py_None; } // Method: setPerveance(double perveance) static PyObject *DanilovEnvelopeTracker_setPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; - DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; - double perveance; - if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { - ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - setPerveance(double perveance) - parameters are needed."); - } - cpp_DanilovEnvelopeTracker->setPerveance(perveance); - Py_INCREF(Py_None); - return Py_None; + pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; + double perveance; + if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { + ORBIT_MPI_Finalize("PyDanilovEnvelopeTracker - setPerveance(double perveance) - parameters are needed."); + } + cpp_DanilovEnvelopeTracker->setPerveance(perveance); + Py_INCREF(Py_None); + return Py_None; } // Method: getPerveance() static PyObject *DanilovEnvelopeTracker_getPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; - DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; - double perveance = cpp_DanilovEnvelopeTracker->getPerveance(); - return Py_BuildValue("d", perveance); + pyORBIT_Object *pyDanilovEnvelopeTracker = (pyORBIT_Object *)self; + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)pyDanilovEnvelopeTracker->cpp_obj; + double perveance = cpp_DanilovEnvelopeTracker->getPerveance(); + return Py_BuildValue("d", perveance); } // Destructor for python DanilovEnvelopeTracker class (__del__ method) static void DanilovEnvelopeTracker_del(pyORBIT_Object *self) { - DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)self->cpp_obj; - delete cpp_DanilovEnvelopeTracker; - self->ob_base.ob_type->tp_free((PyObject *)self); + DanilovEnvelopeTracker *cpp_DanilovEnvelopeTracker = (DanilovEnvelopeTracker *)self->cpp_obj; + delete cpp_DanilovEnvelopeTracker; + self->ob_base.ob_type->tp_free((PyObject *)self); } // Definition of Python DanilovEnvelopeTracker wrapper class methods. // They will be available from the Python level. static PyMethodDef DanilovEnvelopeTrackerClassMethods[] = { - {"getPerveance", DanilovEnvelopeTracker_getPerveance, METH_VARARGS, "Get space charge perveance."}, - {"setPerveance", DanilovEnvelopeTracker_setPerveance, METH_VARARGS, "Set space charge perveance."}, - {"trackBunch", DanilovEnvelopeTracker_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, - {NULL} + {"getPerveance", DanilovEnvelopeTracker_getPerveance, METH_VARARGS, "Get space charge perveance."}, + {"setPerveance", DanilovEnvelopeTracker_setPerveance, METH_VARARGS, "Set space charge perveance."}, + {"trackBunch", DanilovEnvelopeTracker_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, + {NULL} }; // Definition of Python DanilovEnvelopeTracker wrapper class members. // They will be available from the Python level. -static PyMemberDef DanilovEnvelopeTrackerClassMembers[] = { - {NULL}}; +static PyMemberDef DanilovEnvelopeTrackerClassMembers[] = {{NULL}}; // New python DanilovEnvelopeTracker wrapper type definition. static PyTypeObject pyORBIT_DanilovEnvelopeTracker_Type = { PyVarObject_HEAD_INIT(NULL, 0) "DanilovEnvelopeTracker", /*tp_name*/ - sizeof(pyORBIT_Object), /*tp_basicsize*/ - 0, /*tp_itemsize*/ + sizeof(pyORBIT_Object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ (destructor)DanilovEnvelopeTracker_del, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash */ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ "The DanilovEnvelopeTracker python wrapper", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ DanilovEnvelopeTrackerClassMethods, /* tp_methods */ DanilovEnvelopeTrackerClassMembers, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ (initproc)DanilovEnvelopeTracker_init, /* tp_init */ - 0, /* tp_alloc */ + 0, /* tp_alloc */ DanilovEnvelopeTracker_new, /* tp_new */ }; // Initialization function of the pyDanilovEnvelopeTracker class void initDanilovEnvelopeTracker(PyObject *module) { - if (PyType_Ready(&pyORBIT_DanilovEnvelopeTracker_Type) < 0) - return; - Py_INCREF(&pyORBIT_DanilovEnvelopeTracker_Type); - PyModule_AddObject(module, "DanilovEnvelopeTracker", (PyObject *)&pyORBIT_DanilovEnvelopeTracker_Type); + if (PyType_Ready(&pyORBIT_DanilovEnvelopeTracker_Type) < 0) { + return; + } + Py_INCREF(&pyORBIT_DanilovEnvelopeTracker_Type); + PyModule_AddObject(module, "DanilovEnvelopeTracker", (PyObject *)&pyORBIT_DanilovEnvelopeTracker_Type); } #ifdef __cplusplus } #endif -// end of namespace wrap_envelope } // namespace wrap_envelope diff --git a/src/envelope/wrap_envelope.cc b/src/envelope/wrap_envelope.cc index 4d95ac57..1e6d8468 100644 --- a/src/envelope/wrap_envelope.cc +++ b/src/envelope/wrap_envelope.cc @@ -4,10 +4,9 @@ #include "pyORBIT_Object.hh" #include "wrap_bunch.hh" +#include "wrap_danilov_envelope_tracker.hh" #include "wrap_envelope.hh" #include "wrap_kv_envelope_tracker.hh" -#include "wrap_danilov_envelope_tracker.hh" - namespace wrap_envelope { @@ -18,21 +17,22 @@ extern "C" { static PyMethodDef envelopeModuleMethods[] = {{NULL, NULL}}; static struct PyModuleDef cModPyDem = { - PyModuleDef_HEAD_INIT, - "envelope", "Beam envelope solvers", - -1, - envelopeModuleMethods + PyModuleDef_HEAD_INIT, + "envelope", + "Beam envelope solvers", + -1, + envelopeModuleMethods }; PyMODINIT_FUNC initenvelope() { - PyObject *module = PyModule_Create(&cModPyDem); - wrap_envelope::initKVEnvelopeTracker(module); - wrap_envelope::initDanilovEnvelopeTracker(module); - return module; + PyObject *module = PyModule_Create(&cModPyDem); + wrap_envelope::initKVEnvelopeTracker(module); + wrap_envelope::initDanilovEnvelopeTracker(module); + return module; } #ifdef __cplusplus } #endif -} +} // namespace wrap_envelope diff --git a/src/envelope/wrap_envelope.hh b/src/envelope/wrap_envelope.hh index 7d14333a..fd7663ca 100644 --- a/src/envelope/wrap_envelope.hh +++ b/src/envelope/wrap_envelope.hh @@ -8,7 +8,7 @@ extern "C" { #endif namespace wrap_envelope { - PyMODINIT_FUNC initenvelope(); +PyMODINIT_FUNC initenvelope(); } #ifdef __cplusplus diff --git a/src/envelope/wrap_kv_envelope_tracker.cc b/src/envelope/wrap_kv_envelope_tracker.cc index 64354d63..cd5406f8 100644 --- a/src/envelope/wrap_kv_envelope_tracker.cc +++ b/src/envelope/wrap_kv_envelope_tracker.cc @@ -17,182 +17,181 @@ extern "C" { // Constructor for Python class wrapping KVEnvelopeTracker instance. // It never will be called directly. static PyObject *KVEnvelopeTracker_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - pyORBIT_Object *self; - self = (pyORBIT_Object *)type->tp_alloc(type, 0); - self->cpp_obj = NULL; - return (PyObject *)self; + pyORBIT_Object *self; + self = (pyORBIT_Object *)type->tp_alloc(type, 0); + self->cpp_obj = NULL; + return (PyObject *)self; } // Initialization of Python KVEnvelopeTracker class. // This is implementation of the __init__ method. static int KVEnvelopeTracker_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) { - double perveance = 0.0; - double eps_x = 1.0; - double eps_y = 1.0; - self->cpp_obj = new KVEnvelopeTracker(perveance, eps_x, eps_y); - ((KVEnvelopeTracker *)self->cpp_obj)->setPyWrapper((PyObject *)self); - return 0; + double perveance = 0.0; + double eps_x = 1.0; + double eps_y = 1.0; + self->cpp_obj = new KVEnvelopeTracker(perveance, eps_x, eps_y); + ((KVEnvelopeTracker *)self->cpp_obj)->setPyWrapper((PyObject *)self); + return 0; } // Method: trackBunch(Bunch* bunch, double length) static PyObject *KVEnvelopeTracker_trackBunch(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - PyObject *pyBunch; - double length; - if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { - ORBIT_MPI_Finalize("PyKVEnvelopeTracker - trackBunch(Bunch* bunch, double length) - parameters are needed."); - } - PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); - if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { - ORBIT_MPI_Finalize("PyKVEnvelopeTracker - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); - } - Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; - cpp_KVEnvelopeTracker->trackBunch(cpp_bunch, length); - Py_INCREF(Py_None); - return Py_None; + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + PyObject *pyBunch; + double length; + if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - trackBunch(Bunch* bunch, double length) - parameters are needed."); + } + PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch"); + if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch."); + } + Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj; + cpp_KVEnvelopeTracker->trackBunch(cpp_bunch, length); + Py_INCREF(Py_None); + return Py_None; } // Method: setPerveance(double perveance) static PyObject *KVEnvelopeTracker_setPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - double perveance; - if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { - ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setPerveance(double perveance) - parameters are needed."); - } - cpp_KVEnvelopeTracker->setPerveance(perveance); - Py_INCREF(Py_None); - return Py_None; + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double perveance; + if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setPerveance(double perveance) - parameters are needed."); + } + cpp_KVEnvelopeTracker->setPerveance(perveance); + Py_INCREF(Py_None); + return Py_None; } // Method: setEmittanceX(double emittance_x) static PyObject *KVEnvelopeTracker_setEmittanceX(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - double emittance_x; - if (!PyArg_ParseTuple(args, "d:setEmittanceX", &emittance_x)) { - ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setEmittanceX(double emittance_x) - parameters are needed."); - } - cpp_KVEnvelopeTracker->setEmittanceX(emittance_x); - Py_INCREF(Py_None); - return Py_None; + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double emittance_x; + if (!PyArg_ParseTuple(args, "d:setEmittanceX", &emittance_x)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setEmittanceX(double emittance_x) - parameters are needed."); + } + cpp_KVEnvelopeTracker->setEmittanceX(emittance_x); + Py_INCREF(Py_None); + return Py_None; } // Method: setEmittanceY(double emittance_y) static PyObject *KVEnvelopeTracker_setEmittanceY(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - double emittance_y; - if (!PyArg_ParseTuple(args, "d:setEmittanceY", &emittance_y)) { - ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setEmittanceY(double emittance_y) - parameters are needed."); - } - cpp_KVEnvelopeTracker->setEmittanceY(emittance_y); - Py_INCREF(Py_None); - return Py_None; + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double emittance_y; + if (!PyArg_ParseTuple(args, "d:setEmittanceY", &emittance_y)) { + ORBIT_MPI_Finalize("PyKVEnvelopeTracker - setEmittanceY(double emittance_y) - parameters are needed."); + } + cpp_KVEnvelopeTracker->setEmittanceY(emittance_y); + Py_INCREF(Py_None); + return Py_None; } // Method: getPerveance() static PyObject *KVEnvelopeTracker_getPerveance(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - double perveance = cpp_KVEnvelopeTracker->getPerveance(); - return Py_BuildValue("d", perveance); + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double perveance = cpp_KVEnvelopeTracker->getPerveance(); + return Py_BuildValue("d", perveance); } // Method: getEmittanceX() static PyObject *KVEnvelopeTracker_getEmittanceX(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - double eps_x = cpp_KVEnvelopeTracker->getEmittanceX(); - return Py_BuildValue("d", eps_x); + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double eps_x = cpp_KVEnvelopeTracker->getEmittanceX(); + return Py_BuildValue("d", eps_x); } // Method: getEmittanceY() static PyObject *KVEnvelopeTracker_getEmittanceY(PyObject *self, PyObject *args) { - pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; - double eps_y = cpp_KVEnvelopeTracker->getEmittanceY(); - return Py_BuildValue("d", eps_y); + pyORBIT_Object *pyKVEnvelopeTracker = (pyORBIT_Object *)self; + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)pyKVEnvelopeTracker->cpp_obj; + double eps_y = cpp_KVEnvelopeTracker->getEmittanceY(); + return Py_BuildValue("d", eps_y); } // Destructor for python KVEnvelopeTracker class (__del__ method) static void KVEnvelopeTracker_del(pyORBIT_Object *self) { - KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)self->cpp_obj; - delete cpp_KVEnvelopeTracker; - self->ob_base.ob_type->tp_free((PyObject *)self); + KVEnvelopeTracker *cpp_KVEnvelopeTracker = (KVEnvelopeTracker *)self->cpp_obj; + delete cpp_KVEnvelopeTracker; + self->ob_base.ob_type->tp_free((PyObject *)self); } // Definition of Python KVEnvelopeTracker wrapper class methods. // They will be available from the Python level. static PyMethodDef KVEnvelopeTrackerClassMethods[] = { - {"getEmittanceX", KVEnvelopeTracker_getEmittanceX, METH_VARARGS, "Get emittance (x)."}, - {"getEmittanceY", KVEnvelopeTracker_getEmittanceY, METH_VARARGS, "Get emittance (y)."}, - {"getPerveance", KVEnvelopeTracker_getPerveance, METH_VARARGS, "Get space charge perveance."}, - {"setEmittanceX", KVEnvelopeTracker_setEmittanceX, METH_VARARGS, "Set emittance (x)."}, - {"setEmittanceY", KVEnvelopeTracker_setEmittanceY, METH_VARARGS, "Set emittance (y)."}, - {"setPerveance", KVEnvelopeTracker_setPerveance, METH_VARARGS, "Set space charge perveance."}, - {"trackBunch", KVEnvelopeTracker_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, - {NULL} + {"getEmittanceX", KVEnvelopeTracker_getEmittanceX, METH_VARARGS, "Get emittance (x)."}, + {"getEmittanceY", KVEnvelopeTracker_getEmittanceY, METH_VARARGS, "Get emittance (y)."}, + {"getPerveance", KVEnvelopeTracker_getPerveance, METH_VARARGS, "Get space charge perveance."}, + {"setEmittanceX", KVEnvelopeTracker_setEmittanceX, METH_VARARGS, "Set emittance (x)."}, + {"setEmittanceY", KVEnvelopeTracker_setEmittanceY, METH_VARARGS, "Set emittance (y)."}, + {"setPerveance", KVEnvelopeTracker_setPerveance, METH_VARARGS, "Set space charge perveance."}, + {"trackBunch", KVEnvelopeTracker_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."}, + {NULL} }; // Definition of Python KVEnvelopeTracker wrapper class members. // They will be available from the Python level. -static PyMemberDef KVEnvelopeTrackerClassMembers[] = { - {NULL}}; +static PyMemberDef KVEnvelopeTrackerClassMembers[] = {{NULL}}; // New python KVEnvelopeTracker wrapper type definition. static PyTypeObject pyORBIT_KVEnvelopeTracker_Type = { PyVarObject_HEAD_INIT(NULL, 0) "KVEnvelopeTracker", /*tp_name*/ - sizeof(pyORBIT_Object), /*tp_basicsize*/ - 0, /*tp_itemsize*/ + sizeof(pyORBIT_Object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ (destructor)KVEnvelopeTracker_del, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash */ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ "The KVEnvelopeTracker python wrapper", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ KVEnvelopeTrackerClassMethods, /* tp_methods */ KVEnvelopeTrackerClassMembers, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ (initproc)KVEnvelopeTracker_init, /* tp_init */ - 0, /* tp_alloc */ + 0, /* tp_alloc */ KVEnvelopeTracker_new, /* tp_new */ }; // Initialization function of the pyKVEnvelopeTracker class void initKVEnvelopeTracker(PyObject *module) { - if (PyType_Ready(&pyORBIT_KVEnvelopeTracker_Type) < 0) - return; - Py_INCREF(&pyORBIT_KVEnvelopeTracker_Type); - PyModule_AddObject(module, "KVEnvelopeTracker", (PyObject *)&pyORBIT_KVEnvelopeTracker_Type); + if (PyType_Ready(&pyORBIT_KVEnvelopeTracker_Type) < 0) { + return; + } + Py_INCREF(&pyORBIT_KVEnvelopeTracker_Type); + PyModule_AddObject(module, "KVEnvelopeTracker", (PyObject *)&pyORBIT_KVEnvelopeTracker_Type); } #ifdef __cplusplus } #endif -// end of namespace wrap_envelope } // namespace wrap_envelope From de46f694931a9360340afe140569530926afa139 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sun, 21 Sep 2025 13:59:58 -0400 Subject: [PATCH 32/34] Clean up examples --- examples/Envelope/bench_danilov.py | 4 ++-- examples/Envelope/bench_danilov_particle.py | 8 ++++---- examples/Envelope/bench_kv_particle.py | 7 +++---- examples/Envelope/match_danilov.py | 12 ++++++++++-- py/orbit/envelope/danilov.py | 2 -- py/orbit/envelope/kv.py | 2 -- 6 files changed, 19 insertions(+), 16 deletions(-) diff --git a/examples/Envelope/bench_danilov.py b/examples/Envelope/bench_danilov.py index bc9a347f..7b760996 100644 --- a/examples/Envelope/bench_danilov.py +++ b/examples/Envelope/bench_danilov.py @@ -85,7 +85,7 @@ histories = {} -history = tracker.track(envelope_init.copy(), periods=args.periods, history=True) +envelope, history = tracker.track(envelope_init.copy(), periods=args.periods, history=True) histories["envelope"] = copy.deepcopy(history) @@ -116,7 +116,7 @@ for periods in range(args.periods): lattice.trackBunch(bunch, actionContainer=action_container) -history = monitor.package_history() +history = monitor.get_history() histories["bunch"] = copy.deepcopy(history) diff --git a/examples/Envelope/bench_danilov_particle.py b/examples/Envelope/bench_danilov_particle.py index 8f2d48a3..92d59061 100644 --- a/examples/Envelope/bench_danilov_particle.py +++ b/examples/Envelope/bench_danilov_particle.py @@ -38,12 +38,12 @@ parser = argparse.ArgumentParser() parser.add_argument("--phase-adv", type=float, default=100.0) -parser.add_argument("--intensity", type=float, default=10.0e14) +parser.add_argument("--intensity", type=float, default=7.0e14) parser.add_argument("--eps_x", type=float, default=10.00e-06) parser.add_argument("--eps_y", type=float, default=10.00e-06) parser.add_argument("--max-part-length", type=float, default=0.1) parser.add_argument("--mismatch", type=float, default=0.0) -parser.add_argument("--periods", type=int, default=50) +parser.add_argument("--periods", type=int, default=100) args = parser.parse_args() @@ -59,7 +59,7 @@ # -------------------------------------------------------------------------------------- envelope = DanilovEnvelope( - eps_1=20.00e-06, + eps_1=(args.eps_x + args.eps_y), eps_2=0.0, mass=0.938, kin_energy=1.0, @@ -116,7 +116,7 @@ particles_tbt["envelope"].append(particles.copy()) -# Track bunch +# Track bunch with test particles # -------------------------------------------------------------------------------------- def set_particle_macrosizes(bunch: Bunch, macrosizes: list[float]) -> Bunch: diff --git a/examples/Envelope/bench_kv_particle.py b/examples/Envelope/bench_kv_particle.py index 3561614a..8ff39a61 100644 --- a/examples/Envelope/bench_kv_particle.py +++ b/examples/Envelope/bench_kv_particle.py @@ -38,12 +38,12 @@ parser = argparse.ArgumentParser() parser.add_argument("--phase-adv", type=float, default=100.0) -parser.add_argument("--intensity", type=float, default=10.0e14) +parser.add_argument("--intensity", type=float, default=7.0e14) parser.add_argument("--eps_x", type=float, default=10.00e-06) parser.add_argument("--eps_y", type=float, default=10.00e-06) parser.add_argument("--max-part-length", type=float, default=0.1) parser.add_argument("--mismatch", type=float, default=0.0) -parser.add_argument("--periods", type=int, default=50) +parser.add_argument("--periods", type=int, default=100) args = parser.parse_args() @@ -116,7 +116,7 @@ particles_tbt["envelope"].append(particles.copy()) -# Track bunch +# Track bunch with test particles # -------------------------------------------------------------------------------------- def set_particle_macrosizes(bunch: Bunch, macrosizes: list[float]) -> Bunch: @@ -143,7 +143,6 @@ def set_particle_macrosizes(bunch: Bunch, macrosizes: list[float]) -> Bunch: bunch_size = 128_000 bunch = envelope_init.to_bunch(env=False, size=bunch_size) - for i in range(test_particles.shape[0]): bunch.addParticle(*test_particles[i]) diff --git a/examples/Envelope/match_danilov.py b/examples/Envelope/match_danilov.py index 8bf9047b..80b3a9d9 100644 --- a/examples/Envelope/match_danilov.py +++ b/examples/Envelope/match_danilov.py @@ -75,6 +75,15 @@ envelopes["mismatched"] = envelope.copy() tracker.match(envelope, periods=args.periods, method="replace_avg", verbose=2) +# tracker.match( +# envelope, +# periods=args.periods, +# method="least_squares", +# xtol=1e-15, +# ftol=1e-15, +# gtol=1e-15, +# verbose=2 +# ) envelopes["matched"] = envelope.copy() @@ -82,9 +91,8 @@ # -------------------------------------------------------------------------------------- histories = {} - for key, envelope in envelopes.items(): - history = tracker.track(envelope, periods=args.periods, history=True) + envelope, history = tracker.track(envelope, periods=args.periods, history=True) histories[key] = copy.deepcopy(history) diff --git a/py/orbit/envelope/danilov.py b/py/orbit/envelope/danilov.py index 9f8398e8..aa494d83 100644 --- a/py/orbit/envelope/danilov.py +++ b/py/orbit/envelope/danilov.py @@ -1,5 +1,4 @@ """Envelope model for Danilov distribution.""" - import copy import time from typing import Callable @@ -63,7 +62,6 @@ class DanilovEnvelope: The Danilov distribution is the limit of the KV distribution as the emittance goes to zero in one of the planes. """ - def __init__( self, eps_1: float, diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index 454fa752..cb654b05 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -1,5 +1,4 @@ """Envelope model for upright KV distribution.""" - import copy import math import time @@ -33,7 +32,6 @@ class KVEnvelope: """Models KV distribution.""" - def __init__( self, eps_x: float, From 911a2ec4f426c4372d92a826bb8013e0c72fa31c Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sun, 21 Sep 2025 14:06:14 -0400 Subject: [PATCH 33/34] Update plotting examples: --- examples/Envelope/plot_danilov.py | 17 ++++++++++++++++- examples/Envelope/plot_kv.py | 17 ++++++++++++++++- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/examples/Envelope/plot_danilov.py b/examples/Envelope/plot_danilov.py index 4f1692f3..76a0d985 100644 --- a/examples/Envelope/plot_danilov.py +++ b/examples/Envelope/plot_danilov.py @@ -1,3 +1,5 @@ +import os +import pathlib import numpy as np import matplotlib.pyplot as plt @@ -6,6 +8,11 @@ plt.style.use("style.mplstyle") +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + envelope = DanilovEnvelope( eps_1=20.00e-06, eps_2=0.0, @@ -24,8 +31,16 @@ for i in range(4): for j in range(4): ax = axs[i, j] - ax.hist2d(x[:, j], x[:, i], bins=50, range=[limits[j], limits[i]]) + ax.hist2d(x[:, j], x[:, i], bins=50, range=[limits[j], limits[i]], cmap="Blues") for ax in axs.flat: ax.set_xticks([]) ax.set_yticks([]) +for i, dim in enumerate(["x", "xp", "y", "yp"]): + axs[i, 0].set_ylabel(dim) + axs[3, i].set_xlabel(dim) +fig.align_ylabels() + +filename = "fig_corner.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) plt.show() diff --git a/examples/Envelope/plot_kv.py b/examples/Envelope/plot_kv.py index c6258d9d..e11e5a22 100644 --- a/examples/Envelope/plot_kv.py +++ b/examples/Envelope/plot_kv.py @@ -1,3 +1,5 @@ +import os +import pathlib import numpy as np import matplotlib.pyplot as plt @@ -6,6 +8,11 @@ plt.style.use("style.mplstyle") +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + envelope = KVEnvelope( eps_x=10.00e-06, eps_y=10.00e-06, @@ -23,8 +30,16 @@ for i in range(4): for j in range(4): ax = axs[i, j] - ax.hist2d(x[:, j], x[:, i], bins=50, range=[limits[j], limits[i]]) + ax.hist2d(x[:, j], x[:, i], bins=50, range=[limits[j], limits[i]], cmap="Blues") for ax in axs.flat: ax.set_xticks([]) ax.set_yticks([]) +for i, dim in enumerate(["x", "xp", "y", "yp"]): + axs[i, 0].set_ylabel(dim) + axs[3, i].set_xlabel(dim) +fig.align_ylabels() + +filename = "fig_corner.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) plt.show() From 2090627ff94f0ae750b7e869ba318d1bae12252d Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sun, 21 Sep 2025 16:03:33 -0400 Subject: [PATCH 34/34] Change plotting in matching examples --- examples/Envelope/match_danilov.py | 38 ++++++++++++------------------ examples/Envelope/match_kv.py | 2 +- 2 files changed, 16 insertions(+), 24 deletions(-) diff --git a/examples/Envelope/match_danilov.py b/examples/Envelope/match_danilov.py index 80b3a9d9..26119e60 100644 --- a/examples/Envelope/match_danilov.py +++ b/examples/Envelope/match_danilov.py @@ -90,31 +90,23 @@ # Plot results bunch # -------------------------------------------------------------------------------------- -histories = {} -for key, envelope in envelopes.items(): - envelope, history = tracker.track(envelope, periods=args.periods, history=True) - histories[key] = copy.deepcopy(history) +_, history = tracker.track(envelopes["matched"], periods=args.periods, history=True) +_, history_unmatched = tracker.track(envelopes["mismatched"], periods=args.periods, history=True) figwidth = 3.0 * args.periods -figwidth = min(figwidth, 6.0) - -fig, axs = plt.subplots(figsize=(figwidth, 3.0), nrows=2, sharex=True, constrained_layout=True) -for i, key in enumerate(["matched", "mismatched"]): - alpha = [1.0, 0.15][i] - axs[0].plot(histories[key]["s"], histories[key]["xrms"] * 1000.0, alpha=alpha, color="blue") - axs[0].plot(histories[key]["s"], histories[key]["yrms"] * 1000.0, alpha=alpha, color="red") - axs[1].plot(histories[key]["s"], histories[key]["rxy"], alpha=alpha, color="black") - -axs[0].set_ylim(0.0, axs[0].get_ylim()[1]) -axs[1].set_ylim(-1.0, 1.0) - -for ax in axs: - ax.set_xlabel("Distance [m]") -axs[0].set_ylabel("Size [mm]") -axs[1].set_ylabel("rxy") - -filename = "fig_match.png" +figwidth = min(figwidth, 10.0) + +fig, ax = plt.subplots(figsize=(figwidth, 2.5), constrained_layout=True) +ax.plot(history["s"], history["xrms"] * 1000.0, color="blue", alpha=1.0) +ax.plot(history["s"], history["yrms"] * 1000.0, color="red", alpha=1.0) +ax.plot(history_unmatched["s"], history_unmatched["xrms"] * 1000.0, color="blue", alpha=0.2) +ax.plot(history_unmatched["s"], history_unmatched["yrms"] * 1000.0, color="red", alpha=0.2) +ax.set_ylim(0.0, ax.get_ylim()[1]) +ax.set_xlabel("Distance [m]") +ax.set_ylabel("Size [mm]") + +filename = "fig_match_rms.png" filename = os.path.join(output_dir, filename) plt.savefig(filename, dpi=300) -plt.show() +plt.show() \ No newline at end of file diff --git a/examples/Envelope/match_kv.py b/examples/Envelope/match_kv.py index 8c4306b9..77bb191a 100644 --- a/examples/Envelope/match_kv.py +++ b/examples/Envelope/match_kv.py @@ -85,7 +85,7 @@ _, history = tracker.track(envelope, periods=args.periods, history=True) _, history_unmatched = tracker.track(envelope_unmatched, periods=args.periods, history=True) -figwidth = 4.0 * args.periods +figwidth = 3.0 * args.periods figwidth = min(figwidth, 10.0) fig, ax = plt.subplots(figsize=(figwidth, 2.5), constrained_layout=True)

eX=6oVLhe2 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 XBrw7y@Z=&!qntT)PA&6<#ohk_hH@3q literal 0 HcmV?d00001 diff --git a/examples/Envelope/plot_kv.py b/examples/Envelope/plot_kv.py new file mode 100644 index 00000000..9484fd2d --- /dev/null +++ b/examples/Envelope/plot_kv.py @@ -0,0 +1,30 @@ +import numpy as np +import matplotlib.pyplot as plt + +from orbit.envelope import KVEnvelope + +plt.style.use("style.mplstyle") + + +envelope = KVEnvelope( + eps_x=10.00e-06, + eps_y=10.00e-06, + mass=0.938, + kin_energy=1.0, + length=100.0, + intensity=0.0, +) + +x = envelope.sample(100_000) +xmax = np.std(x, axis=0) * 3.0 +limits = list(zip(-xmax, xmax)) + +fig, axs = plt.subplots(ncols=4, nrows=4, figsize=(4, 4), constrained_layout=True) +for i in range(4): + for j in range(4): + ax = axs[i, j] + ax.hist2d(x[:, j], x[:, i], bins=50, range=[limits[j], limits[i]]) +for ax in axs.flat: + ax.set_xticks([]) + ax.set_yticks([]) +plt.show() \ No newline at end of file diff --git a/examples/Envelope/style.mplstyle b/examples/Envelope/style.mplstyle new file mode 100644 index 00000000..0e7c57d1 --- /dev/null +++ b/examples/Envelope/style.mplstyle @@ -0,0 +1,4 @@ +axes.linewidth: 1.25 +figure.constrained_layout.use: True +xtick.minor.visible: True +ytick.minor.visible: True \ No newline at end of file diff --git a/examples/Envelope/utils.py b/examples/Envelope/utils.py new file mode 100644 index 00000000..b9af88c6 --- /dev/null +++ b/examples/Envelope/utils.py @@ -0,0 +1,270 @@ +import copy +import numpy as np +import scipy.optimize + +from orbit.core.bunch import Bunch +from orbit.core.bunch import BunchTwissAnalysis +from orbit.bunch_generators import TwissContainer +from orbit.bunch_generators import GaussDist2D +from orbit.bunch_generators import KVDist2D +from orbit.bunch_generators import WaterBagDist2D +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.teapot import TEAPOT_Lattice +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.teapot import DriftTEAPOT +from orbit.teapot import QuadTEAPOT + + +def split_node(node: AccNode, max_part_length: float = None) -> AccNode: + if max_part_length: + if node.getLength() > max_part_length: + node.setnParts(1 + int(node.getLength() / max_part_length)) + return node + + +def get_phase_adv(lattice: AccLattice, mass: float, kin_energy: float) -> np.ndarray: + bunch = Bunch() + bunch.mass(mass) + bunch.getSyncParticle().kinEnergy(kin_energy) + matrix_lattice = TEAPOT_MATRIX_Lattice(lattice, bunch) + lattice_params = matrix_lattice.getRingParametersDict() + phase_adv = [ + lattice_params["fractional tune x"], + lattice_params["fractional tune y"], + ] + phase_adv = np.array(phase_adv) + phase_adv = phase_adv * 2.0 * np.pi + return phase_adv + + +def make_fodo_lattice( + phase_adv_x: float, + phase_adv_y: float, + length: float, + mass: float, + kin_energy: float, + fill_frac: float = 0.5, + start: str = "drift", + fringe: bool = False, + max_part_length: float = 0.1, + verbose: bool = False, +) -> AccLattice: + """Create FODO lattice with specified phase advances. + + Args: + phase_adv_x: Phase advance in x plane [rad]. + phase_adv_y: Phase advance in y plane [rad]. + length: Length of the lattice [m]. + mass: Particle mass [GeV/c^2] + kin_energy: Synchronous particle kinetic energy [GeV]. + fill_frac : Fraction of the lattice occupied by quadrupoles. + start : str + "drift": + O-F-F-O-O-D-D-O. + "quad": + F-O-O-D-D-O-O-F + fringe: Toggles fringe fields before/after quads. + max_part_length: Maximum node part length [m]. + verbose: Print optimization status. + + Returns: + TEAPOT_Lattice + """ + + def _make_lattice(k1: float, k2: float) -> AccLattice: + """Create FODO lattice with specified focusing strengths. + + k1 and k2 are the focusing strengths of the + focusing (1st) and defocusing (2nd) quads, respectively. + """ + length_quad = length * fill_frac / 2.0 + length_drift = length * (1.0 - fill_frac) / 2.0 + + if start == "quad": + drift_nodes = [ + DriftTEAPOT("drift1"), + DriftTEAPOT("drift2"), + ] + quad_nodes = [ + QuadTEAPOT("qf1"), + QuadTEAPOT("qd"), + QuadTEAPOT("qf2"), + ] + + drift_nodes[0].setLength(length_drift) + drift_nodes[1].setLength(length_drift) + + quad_nodes[0].setLength(length_quad * 0.5) + quad_nodes[1].setLength(length_quad) + quad_nodes[2].setLength(length_quad * 0.5) + + quad_nodes[0].setParam("kq", +k1) + quad_nodes[1].setParam("kq", -k2) + quad_nodes[2].setParam("kq", +k1) + + lattice = TEAPOT_Lattice() + lattice.addNode(quad_nodes[0]) + lattice.addNode(drift_nodes[0]) + lattice.addNode(quad_nodes[1]) + lattice.addNode(drift_nodes[1]) + lattice.addNode(quad_nodes[2]) + lattice.initialize() + + elif start == "drift": + + drift_nodes = [ + DriftTEAPOT("drift1"), + DriftTEAPOT("drift2"), + DriftTEAPOT("drift3"), + ] + quad_nodes = [ + QuadTEAPOT("qf"), + QuadTEAPOT("qd"), + ] + + drift_nodes[0].setLength(length_drift * 0.5) + drift_nodes[1].setLength(length_drift) + drift_nodes[2].setLength(length_drift * 0.5) + + quad_nodes[0].setLength(length_quad) + quad_nodes[1].setLength(length_quad) + + quad_nodes[0].setParam("kq", +k1) + quad_nodes[1].setParam("kq", -k2) + + lattice = TEAPOT_Lattice() + lattice.addNode(drift_nodes[0]) + lattice.addNode(quad_nodes[0]) + lattice.addNode(drift_nodes[1]) + lattice.addNode(quad_nodes[1]) + lattice.addNode(drift_nodes[2]) + lattice.initialize() + + # Toggle fringe fields + for node in lattice.getNodes(): + node.setUsageFringeFieldIN(fringe) + node.setUsageFringeFieldOUT(fringe) + + lattice.initialize() + return lattice + + def loss_function(parameters: np.ndarray) -> float: + lattice = _make_lattice(*parameters) + phase_adv_calc = get_phase_adv(lattice, mass=mass, kin_energy=kin_energy) + phase_adv_targ = np.array([phase_adv_x, phase_adv_y]) + return np.abs(phase_adv_calc - phase_adv_targ) + + parameters = np.array([0.5, 0.5]) # ~ 80 deg phase advance + result = scipy.optimize.least_squares(loss_function, parameters, verbose=verbose) + lattice = _make_lattice(*result.x) + + for node in lattice.getNodes(): + node = split_node(node, max_part_length) + + if verbose: + phase_adv_calc = get_phase_adv(lattice, mass=mass, kin_energy=kin_energy) + phase_adv_targ = np.array([phase_adv_x, phase_adv_y]) + phase_adv_calc *= 180.0 / np.pi + phase_adv_targ *= 180.0 / np.pi + print(f"phase_adv_x = {phase_adv_calc[0]} (target={phase_adv_targ[0]})") + print(f"phase_adv_y = {phase_adv_calc[1]} (target={phase_adv_targ[1]})") + + return lattice + + +def get_bunch_coords(bunch: Bunch, axis: tuple[int, ...] = None) -> np.ndarray: + if axis is None: + axis = tuple(range(6)) + + X = np.zeros((bunch.getSize(), 6)) + for i in range(bunch.getSize()): + X[i, 0] = bunch.x(i) + X[i, 1] = bunch.xp(i) + X[i, 2] = bunch.y(i) + X[i, 3] = bunch.yp(i) + X[i, 4] = bunch.z(i) + X[i, 5] = bunch.dE(i) + return X[:, axis] + + +def get_bunch_cov(bunch: Bunch) -> np.ndarray: + calc = BunchTwissAnalysis() + calc.computeBunchMoments(bunch, 2, 0, 0) + + cov_matrix = np.zeros((6, 6)) + for i in range(6): + for j in range(i + 1): + cov_matrix[i, j] = calc.getCorrelation(j, i) + cov_matrix[j, i] = cov_matrix[i, j] + return cov_matrix + + +class BunchMonitor: + def __init__(self, verbose: int = 1) -> None: + self.distance = 0.0 + self._pos_old = 0.0 + self._pos_new = 0.0 + self.verbose = verbose + + self.history = {} + for key in [ + "s", + "xrms", + "yrms", + "epsx", + "epsy", + "cov_00", + "cov_01", + "cov_02", + "cov_03", + "cov_11", + "cov_12", + "cov_13", + "cov_22", + "cov_23", + "cov_33", + "rxy", + ]: + self.history[key] = [] + + def package_history(self) -> None: + history = copy.deepcopy(self.history) + for key in history: + history[key] = np.array(history[key]) + history["s"] -= history["s"][0] + return history + + def __call__(self, params_dict: dict) -> None: + bunch = params_dict["bunch"] + node = params_dict["node"] + + self._pos_new = params_dict["path_length"] + if self._pos_old > self._pos_new: + self._pos_old = 0.0 + self.distance += self._pos_new - self._pos_old + self._pos_old = self._pos_new + + cov_matrix = get_bunch_cov(bunch) + + for i in range(4): + for j in range(i, 4): + key = f"cov_{i}{j}" + self.history[key].append(cov_matrix[i, j]) + + self.history["s"].append(self.distance) + self.history["xrms"].append(np.sqrt(cov_matrix[0, 0])) + self.history["yrms"].append(np.sqrt(cov_matrix[2, 2])) + self.history["epsx"].append(np.sqrt(np.linalg.det(cov_matrix[0:2, 0:2]))) + self.history["epsy"].append(np.sqrt(np.linalg.det(cov_matrix[2:4, 2:4]))) + self.history["rxy"].append( + self.history["cov_02"][-1] + / np.sqrt(self.history["cov_00"][-1] * self.history["cov_22"][-1]) + ) + + if self.verbose: + message = "" + message += "s={:0.3f} ".format(self.history["s"][-1]) + message += "xrms={:0.3f} ".format(self.history["xrms"][-1] * 1000.0) + message += "yrms={:0.3f} ".format(self.history["yrms"][-1] * 1000.0) + print(message) \ No newline at end of file From cf818f11270cd879f49e9bfeb2259ea472c87762 Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 21:14:13 -0400 Subject: [PATCH 21/34] Set line density rather than intensity --- examples/Envelope/bench_kv.py | 2 +- examples/Envelope/match_kv.py | 4 +- examples/Envelope/plot_kv.py | 2 +- py/orbit/envelope/kv.py | 98 +++++++++++++++-------------------- 4 files changed, 46 insertions(+), 60 deletions(-) diff --git a/examples/Envelope/bench_kv.py b/examples/Envelope/bench_kv.py index bf162bd2..70c9db43 100644 --- a/examples/Envelope/bench_kv.py +++ b/examples/Envelope/bench_kv.py @@ -60,8 +60,8 @@ eps_y=args.eps_y, mass=mass_proton, kin_energy=1.000, + line_density=(args.intensity / 100.0), length=100.0, - intensity=args.intensity, params=None, ) diff --git a/examples/Envelope/match_kv.py b/examples/Envelope/match_kv.py index fdef5052..20c2f25f 100644 --- a/examples/Envelope/match_kv.py +++ b/examples/Envelope/match_kv.py @@ -24,7 +24,7 @@ # -------------------------------------------------------------------------------------- parser = argparse.ArgumentParser() -parser.add_argument("--intensity", type=float, default=100.0) +parser.add_argument("--intensity", type=float, default=100.0e14) parser.add_argument("--eps_x", type=float, default=10.00e-06) parser.add_argument("--eps_y", type=float, default=10.00e-06) parser.add_argument("--max-part-length", type=float, default=0.1) @@ -49,7 +49,7 @@ mass=mass_proton, kin_energy=1.000, length=100.0, - intensity=(args.intensity * 1.00e14), + line_density=(args.intensity / 100.0), params=None, ) diff --git a/examples/Envelope/plot_kv.py b/examples/Envelope/plot_kv.py index 9484fd2d..815c89e5 100644 --- a/examples/Envelope/plot_kv.py +++ b/examples/Envelope/plot_kv.py @@ -11,8 +11,8 @@ eps_y=10.00e-06, mass=0.938, kin_energy=1.0, + line_density=0.0, length=100.0, - intensity=0.0, ) x = envelope.sample(100_000) diff --git a/py/orbit/envelope/kv.py b/py/orbit/envelope/kv.py index e4f26bf3..d3bb56bd 100644 --- a/py/orbit/envelope/kv.py +++ b/py/orbit/envelope/kv.py @@ -31,48 +31,40 @@ class KVEnvelope: - """Models KV distribution. - - Attributes - ---------- - params: ndarray, shape(4,) - The envelope parameters [cx, cx', cy, cy']. The cx and cy parameters - represent the envelope extent along the x and y axis; cx' and cy' are - their derivatives with respect to the distance x. - eps_x: float - The rms emittance of the x-x' distribution: sqrt( - ). - eps_y: float - The rms emittance of the y-y' distribution: sqrt( - ). - mass: float - Particle [GeV/c^2]. - kin_energy: float - Particle kinetic energy [GeV]. - intensity: float - Bunch intensity (number of particles). - length: float - Bunch length [m]. - perveance: float - Dimensionless beam perveance. - """ + """Models KV distribution.""" def __init__( self, eps_x: float, eps_y: float, mass: float, kin_energy: float, + line_density: float, length: float, - intensity: int, params: Iterable[float] = None, ) -> None: + """Constructor. + + Args: + eps_x: RMS emittance in x plane. + eps_y: RMS emittance in y plane. + mass: Particle [GeV/c^2]. + kin_energy: Synchronous particle kinetic energy [GeV]. + line_density: Bunch line density [m]. + length: Bunch length [m] (used to convert to Bunch object). + params: The envelope parameters [cx, cx', cy, cy']. + The cx and cy parameters represent the envelope extent along the x and y + axis; cx' and cy' are their derivatives with respect to the distance x. + """ self.eps_x = eps_x self.eps_y = eps_y self.mass = mass self.kin_energy = kin_energy + self.line_density = line_density self.length = length - self.line_density = None - self.perveance = None - self.set_intensity(intensity) + self.intensity = self.line_density * self.length + self.perveance = 0.0 + self.set_line_density(line_density) self.params = params if self.params is None: @@ -81,15 +73,15 @@ def __init__( self.params = [cx, 0.0, cy, 0.0] self.params = np.array(self.params) - def set_intensity(self, intensity: int) -> None: - self.intensity = intensity - self.line_density = intensity / self.length + def set_line_density(self, line_density: float) -> None: + self.line_density = line_density + self.intensity = self.line_density * self.length self.perveance = get_perveance(self.mass, self.kin_energy, self.line_density) def set_length(self, length: float) -> None: self.length = length - self.set_intensity(self.intensity) - + self.intensity = self.line_density * self.length + def set_params(self, params: np.ndarray) -> None: self.params = np.copy(params) @@ -179,16 +171,12 @@ def sample(self, size: int) -> np.ndarray: A = np.sqrt(np.diag([eps_x, eps_x, eps_y, eps_y])) - particles = np.random.normal(size=(size, 4)) - particles /= np.linalg.norm(particles, axis=1)[:, None] - particles /= np.std(particles, axis=0) - particles = np.matmul(particles, A.T) - particles = np.matmul(particles, V.T) - - particles_full = np.zeros((size, 6)) - particles_full[:, :4] = particles - particles_full[:, 4] = self.length * np.random.uniform(-0.5, 0.5, size=size) - return particles_full + X = np.random.normal(size=(size, 4)) + X /= np.linalg.norm(X, axis=1)[:, None] + X /= np.std(X, axis=0) + X = np.matmul(X, A.T) + X = np.matmul(X, V.T) + return X def from_bunch(self, bunch: Bunch) -> np.ndarray: """Set envelope parameters from Bunch.""" @@ -202,18 +190,14 @@ def from_bunch(self, bunch: Bunch) -> np.ndarray: def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: """Create Bunch object from envelope parameters. - Parameters - ---------- - size : int - Number of macroparticles in the bunch. These are the number of "test" - particles not counting the first particle, which stores the envelope - parameters. - env : bool - If False, do not store the envelope parameters as the first particle. - - Returns - ------- - Bunch + Args: + size: Number of macroparticles in the bunch. + These are the number of "test"particles not counting the first particle, + which stores the envelope parameters. + env: Whether first two particles store envelope parameters. + + Returns: + Bunch with sampled particles. """ bunch = Bunch() bunch.mass(self.mass) @@ -224,9 +208,11 @@ def to_bunch(self, size: int = 0, env: bool = True) -> Bunch: bunch.addParticle(cx, cxp, cy, cyp, 0.0, 0.0) if size: - samples = self.sample(size) + particles = np.zeros((size, 6)) + particles[:, :4] = self.sample(size) + particles[:, 4] = self.length * np.random.uniform(-0.5, 0.5, size=size) for i in range(size): - bunch.addParticle(*samples[i]) + bunch.addParticle(*particles[i]) macrosize = self.intensity / size if self.intensity == 0.0: From c9f1666611a449a6fef65fb496aa04f545c8273e Mon Sep 17 00:00:00 2001 From: austin-hoover Date: Sat, 20 Sep 2025 21:53:37 -0400 Subject: [PATCH 22/34] Add DanilovEnvelope --- examples/Envelope/bench_danilov.py | 159 ++++ examples/Envelope/match_danilov.py | 112 +++ .../outputs/bench_kv/fig_benchmark_rms.png | Bin 134104 -> 0 bytes .../outputs/match_kv/fig_match_rms.png | Bin 151704 -> 0 bytes examples/Envelope/plot_danilov.py | 31 + py/orbit/envelope/__init__.py | 6 +- py/orbit/envelope/danilov.py | 765 ++++++++++++++++++ py/orbit/envelope/meson.build | 1 + py/orbit/envelope/transfer_matrix.py | 205 +++++ 9 files changed, 1276 insertions(+), 3 deletions(-) create mode 100644 examples/Envelope/bench_danilov.py create mode 100644 examples/Envelope/match_danilov.py delete mode 100644 examples/Envelope/outputs/bench_kv/fig_benchmark_rms.png delete mode 100644 examples/Envelope/outputs/match_kv/fig_match_rms.png create mode 100644 examples/Envelope/plot_danilov.py create mode 100644 py/orbit/envelope/transfer_matrix.py diff --git a/examples/Envelope/bench_danilov.py b/examples/Envelope/bench_danilov.py new file mode 100644 index 00000000..79f0aa07 --- /dev/null +++ b/examples/Envelope/bench_danilov.py @@ -0,0 +1,159 @@ +"""Benchmark Danilov envelope tracker vs. PIC.""" +import argparse +import copy +import os +import pathlib +from pprint import pprint + +import numpy as np +import matplotlib.pyplot as plt + +from orbit.core import orbit_mpi +from orbit.core.bunch import Bunch +from orbit.core.bunch import BunchTwissAnalysis +from orbit.core.spacecharge import SpaceChargeCalc2p5D +from orbit.envelope import DanilovEnvelope +from orbit.envelope import DanilovEnvelopeMonitor +from orbit.envelope import DanilovEnvelopeTracker +from orbit.envelope import add_danilov_envelope_tracker_nodes +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.lattice import AccActionsContainer +from orbit.space_charge.sc2p5d import SC2p5D_AccNode +from orbit.space_charge.sc2p5d import setSC2p5DAccNodes +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.utils.consts import mass_proton + +from utils import make_fodo_lattice +from utils import BunchMonitor + +plt.style.use("style.mplstyle") + + +# Parse arguments +# -------------------------------------------------------------------------------------- + +parser = argparse.ArgumentParser() +parser.add_argument("--phase-adv-x", type=float, default=85.0) +parser.add_argument("--phase-adv-y", type=float, default=85.0) +parser.add_argument("--intensity", type=float, default=20.0e14) +parser.add_argument("--max-part-length", type=float, default=0.1) +parser.add_argument("--mismatch", type=float, default=0.0) +parser.add_argument("--periods", type=int, default=5) +args = parser.parse_args() + + +# Setup +# -------------------------------------------------------------------------------------- + +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + +# Set up simulation +# -------------------------------------------------------------------------------------- + +envelope = DanilovEnvelope( + eps_1=20.00e-06, + eps_2=0.0, + mass=0.938, + kin_energy=1.0, + length=100.0, + line_density=(args.intensity / 100.0), + params=None, +) + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv_x), + phase_adv_y=np.radians(args.phase_adv_y), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +tracker = DanilovEnvelopeTracker(lattice, path_length_max=args.max_part_length) +tracker.match_zero_sc(envelope, method="2d") +envelope_init = envelope.copy() + + +# Track envelope +# -------------------------------------------------------------------------------------- + +histories = {} + +history = tracker.track(envelope_init.copy(), periods=args.periods, history=True) +histories["envelope"] = copy.deepcopy(history) + + +# Track bunch +# -------------------------------------------------------------------------------------- + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv_x), + phase_adv_y=np.radians(args.phase_adv_y), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +monitor = BunchMonitor() +action_container = AccActionsContainer() +action_container.addAction(monitor, AccActionsContainer.ENTRANCE) +action_container.addAction(monitor, AccActionsContainer.EXIT) + +sc_calc = SpaceChargeCalc2p5D(128, 128, 1) +sc_path_length_min = 1.00e-06 +sc_nodes = setSC2p5DAccNodes(lattice, sc_path_length_min, sc_calc) + +bunch = envelope_init.to_bunch(env=False, size=128_000) + +for periods in range(args.periods): + lattice.trackBunch(bunch, actionContainer=action_container) + +history = monitor.package_history() +histories["bunch"] = copy.deepcopy(history) + + +# Plot comparison +# -------------------------------------------------------------------------------------- + +figwidth = 3.0 * args.periods +figwidth = min(figwidth, 7.0) + +fig, axs = plt.subplots(nrows=2, figsize=(figwidth, 4.0), sharex=True, sharey=True) +for i, ax in enumerate(axs): + param = ["xrms", "yrms"][i] + for j, key in enumerate(histories): + history = histories[key] + if key == "envelope": + ax.plot( + history["s"], + np.multiply(history[param], 1000.0), + color="black", + lw=1.5, + ) + else: + stride = 10 + ax.plot( + history["s"][::stride], + np.multiply(history[param][::stride], 1000.0), + marker=".", + lw=0, + color="red", + ) + +for ax in axs: + ax.set_ylim(0.0, ax.get_ylim()[1]) +axs[1].set_xlabel("Distance [m]") +axs[0].set_ylabel("RMS x [mm]") +axs[1].set_ylabel("RMS y [mm]") + +filename = "fig_benchmark_rms.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) +plt.show() diff --git a/examples/Envelope/match_danilov.py b/examples/Envelope/match_danilov.py new file mode 100644 index 00000000..f5118766 --- /dev/null +++ b/examples/Envelope/match_danilov.py @@ -0,0 +1,112 @@ +import argparse +import copy +import os +import pathlib + +import numpy as np +import matplotlib.pyplot as plt + +from orbit.envelope import DanilovEnvelope +from orbit.envelope import DanilovEnvelopeMonitor +from orbit.envelope import DanilovEnvelopeTracker +from orbit.lattice import AccLattice +from orbit.lattice import AccNode +from orbit.lattice import AccActionsContainer +from orbit.teapot import TEAPOT_MATRIX_Lattice +from orbit.utils.consts import mass_proton + +from utils import make_fodo_lattice + +plt.style.use("style.mplstyle") + + +# Parse arguments +# -------------------------------------------------------------------------------------- + +parser = argparse.ArgumentParser() +parser.add_argument("--phase-adv-x", type=float, default=85.0) +parser.add_argument("--phase-adv-y", type=float, default=85.0) +parser.add_argument("--intensity", type=float, default=50.0e14) +parser.add_argument("--max-part-length", type=float, default=0.1) +parser.add_argument("--periods", type=int, default=5) +args = parser.parse_args() + + +# Setup +# -------------------------------------------------------------------------------------- + +path = pathlib.Path(__file__) +output_dir = os.path.join("outputs", path.stem) +os.makedirs(output_dir, exist_ok=True) + + +# Set up simulation +# -------------------------------------------------------------------------------------- + +envelope = DanilovEnvelope( + eps_1=20.00e-06, + eps_2=0.0, + mass=0.938, + kin_energy=1.0, + length=100.0, + line_density=(args.intensity / 100.0), + params=None, +) + +lattice = make_fodo_lattice( + phase_adv_x=np.radians(args.phase_adv_x), + phase_adv_y=np.radians(args.phase_adv_y), + length=5.0, + mass=envelope.mass, + kin_energy=envelope.kin_energy, + max_part_length=args.max_part_length, + verbose=1, +) + +tracker = DanilovEnvelopeTracker(lattice, path_length_max=args.max_part_length) + + +# Find periodic envelope +# -------------------------------------------------------------------------------------- + +envelopes = {} + +tracker.match_zero_sc(envelope, method="2d") +envelopes["mismatched"] = envelope.copy() + +tracker.match(envelope, periods=args.periods, method="replace_avg", verbose=2) +envelopes["matched"] = envelope.copy() + + +# Plot results bunch +# -------------------------------------------------------------------------------------- + +histories = {} + +for key, envelope in envelopes.items(): + history = tracker.track(envelope, periods=args.periods, history=True) + histories[key] = copy.deepcopy(history) + + +figwidth = 3.0 * args.periods +figwidth = min(figwidth, 6.0) + +fig, axs = plt.subplots(figsize=(figwidth, 3.0), nrows=2, sharex=True, constrained_layout=True) +for i, key in enumerate(["matched", "mismatched"]): + alpha = [1.0, 0.15][i] + axs[0].plot(histories[key]["s"], histories[key]["xrms"] * 1000.0, alpha=alpha, color="blue") + axs[0].plot(histories[key]["s"], histories[key]["yrms"] * 1000.0, alpha=alpha, color="red") + axs[1].plot(histories[key]["s"], histories[key]["rxy"], alpha=alpha, color="black") + +axs[0].set_ylim(0.0, axs[0].get_ylim()[1]) +axs[1].set_ylim(-1.0, 1.0) + +for ax in axs: + ax.set_xlabel("Distance [m]") +axs[0].set_ylabel("Size [mm]") +axs[1].set_ylabel("rxy") + +filename = "fig_match.png" +filename = os.path.join(output_dir, filename) +plt.savefig(filename, dpi=300) +plt.show() \ No newline at end of file diff --git a/examples/Envelope/outputs/bench_kv/fig_benchmark_rms.png b/examples/Envelope/outputs/bench_kv/fig_benchmark_rms.png deleted file mode 100644 index 65ea7ac3070f9feea510dd60c0c8d22695eedd33..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 134104 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�FER*~yxRuGW4Rj* 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