diff --git a/.mypy.ini b/.mypy.ini index 98bbe47d..50a8effb 100644 --- a/.mypy.ini +++ b/.mypy.ini @@ -2,13 +2,13 @@ python_version = 3.10 # strict = true -warn_unreachable = true -implicit_reexport = true -show_error_codes = true -show_column_numbers = true -ignore_missing_imports = true -warn_unused_configs = true -allow_redefinition = false +warn_unreachable = True +implicit_reexport = True +show_error_codes = True +show_column_numbers = True +ignore_missing_imports = True +warn_unused_configs = True +allow_redefinition = False # ignore files in the tests directory [mypy-tests.*] diff --git a/docs/geos-mesh.rst b/docs/geos-mesh.rst index 82b85519..81d82205 100644 --- a/docs/geos-mesh.rst +++ b/docs/geos-mesh.rst @@ -1,346 +1,10 @@ - -GEOS Mesh Tools +GEOS Mesh tools ==================== +.. toctree:: + :maxdepth: 5 + :caption: Contents: -Mesh Doctor ---------------- - -``mesh-doctor`` is a ``python`` executable that can be used through the command line to perform various checks, validations, and tiny fixes to the ``vtk`` mesh that are meant to be used in ``geos``. -``mesh-doctor`` is organized as a collection of modules with their dedicated sets of options. -The current page will introduce those modules, but the details and all the arguments can be retrieved by using the ``--help`` option for each module. - -Modules -^^^^^^^ - -To list all the modules available through ``mesh-doctor``, you can simply use the ``--help`` option, which will list all available modules as well as a quick summary. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py --help - usage: mesh_doctor.py [-h] [-v] [-q] -i VTK_MESH_FILE - {collocated_nodes,element_volumes,fix_elements_orderings,generate_cube,generate_fractures,generate_global_ids,non_conformal,self_intersecting_elements,supported_elements} - ... - - Inspects meshes for GEOSX. - - positional arguments: - {collocated_nodes,element_volumes,fix_elements_orderings,generate_cube,generate_fractures,generate_global_ids,non_conformal,self_intersecting_elements,supported_elements} - Modules - collocated_nodes - Checks if nodes are collocated. - element_volumes - Checks if the volumes of the elements are greater than "min". - fix_elements_orderings - Reorders the support nodes for the given cell types. - generate_cube - Generate a cube and its fields. - generate_fractures - Splits the mesh to generate the faults and fractures. [EXPERIMENTAL] - generate_global_ids - Adds globals ids for points and cells. - non_conformal - Detects non conformal elements. [EXPERIMENTAL] - self_intersecting_elements - Checks if the faces of the elements are self intersecting. - supported_elements - Check that all the elements of the mesh are supported by GEOSX. - - options: - -h, --help - show this help message and exit - -v Use -v 'INFO', -vv for 'DEBUG'. Defaults to 'WARNING'. - -q Use -q to reduce the verbosity of the output. - -i VTK_MESH_FILE, --vtk-input-file VTK_MESH_FILE - - Note that checks are dynamically loaded. - An option may be missing because of an unloaded module. - Increase verbosity (-v, -vv) to get full information. - -Then, if you are interested in a specific module, you can ask for its documentation using the ``mesh-doctor module_name --help`` pattern. -For example - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py collocated_nodes --help - usage: mesh_doctor.py collocated_nodes [-h] --tolerance TOLERANCE - - options: - -h, --help show this help message and exit - --tolerance TOLERANCE [float]: The absolute distance between two nodes for them to be considered collocated. - -``mesh-doctor`` loads its module dynamically. -If a module can't be loaded, ``mesh-doctor`` will proceed and try to load other modules. -If you see a message like - -.. code-block:: bash - - [1970-04-14 03:07:15,625][WARNING] Could not load module "collocated_nodes": No module named 'vtkmodules' - -then most likely ``mesh-doctor`` could not load the ``collocated_nodes`` module, because the ``vtk`` python package was not found. -Thereafter, the documentation for module ``collocated_nodes`` will not be displayed. -You can solve this issue by installing the dependencies of ``mesh-doctor`` defined in its ``requirements.txt`` file (``python -m pip install -r requirements.txt``). - -Here is a list and brief description of all the modules available. - -``collocated_nodes`` -"""""""""""""""""""" - -Displays the neighboring nodes that are closer to each other than a prescribed threshold. -It is not uncommon to define multiple nodes for the exact same position, which will typically be an issue for ``geos`` and should be fixed. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py collocated_nodes --help - usage: mesh_doctor.py collocated_nodes [-h] --tolerance TOLERANCE - - options: - -h, --help show this help message and exit - --tolerance TOLERANCE [float]: The absolute distance between two nodes for them to be considered collocated. - -``element_volumes`` -""""""""""""""""""" - -Computes the volumes of all the cells and displays the ones that are below a prescribed threshold. -Cells with negative volumes will typically be an issue for ``geos`` and should be fixed. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py element_volumes --help - usage: mesh_doctor.py element_volumes [-h] --min 0.0 - - options: - -h, --help show this help message and exit - --min 0.0 [float]: The minimum acceptable volume. Defaults to 0.0. - -``fix_elements_orderings`` -"""""""""""""""""""""""""" - -It sometimes happens that an exported mesh does not abide by the ``vtk`` orderings. -The ``fix_elements_orderings`` module can rearrange the nodes of given types of elements. -This can be convenient if you cannot regenerate the mesh. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py fix_elements_orderings --help - usage: mesh_doctor.py fix_elements_orderings [-h] [--Hexahedron 1,6,5,4,7,0,2,3] [--Prism5 8,2,0,7,6,9,5,1,4,3] - [--Prism6 11,2,8,10,5,0,9,7,6,1,4,3] [--Pyramid 3,4,0,2,1] - [--Tetrahedron 2,0,3,1] [--Voxel 1,6,5,4,7,0,2,3] - [--Wedge 3,5,4,0,2,1] --output OUTPUT [--data-mode binary, ascii] - - options: - -h, --help show this help message and exit - --Hexahedron 1,6,5,4,7,0,2,3 - [list of integers]: node permutation for "Hexahedron". - --Prism5 8,2,0,7,6,9,5,1,4,3 - [list of integers]: node permutation for "Prism5". - --Prism6 11,2,8,10,5,0,9,7,6,1,4,3 - [list of integers]: node permutation for "Prism6". - --Pyramid 3,4,0,2,1 [list of integers]: node permutation for "Pyramid". - --Tetrahedron 2,0,3,1 [list of integers]: node permutation for "Tetrahedron". - --Voxel 1,6,5,4,7,0,2,3 [list of integers]: node permutation for "Voxel". - --Wedge 3,5,4,0,2,1 [list of integers]: node permutation for "Wedge". - --output OUTPUT [string]: The vtk output file destination. - --data-mode binary, ascii - [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. - -``generate_cube`` -""""""""""""""""" - -This module conveniently generates cubic meshes in ``vtk``. -It can also generate fields with simple values. -This tool can also be useful to generate a trial mesh that will later be refined or customized. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py generate_cube --help - usage: mesh_doctor.py generate_cube [-h] [--x 0:1.5:3] [--y 0:5:10] [--z 0:1] [--nx 2:2] [--ny 1:1] [--nz 4] - [--fields name:support:dim [name:support:dim ...]] [--cells] [--no-cells] - [--points] [--no-points] --output OUTPUT [--data-mode binary, ascii] - - options: - -h, --help show this help message and exit - --x 0:1.5:3 [list of floats]: X coordinates of the points. - --y 0:5:10 [list of floats]: Y coordinates of the points. - --z 0:1 [list of floats]: Z coordinates of the points. - --nx 2:2 [list of integers]: Number of elements in the X direction. - --ny 1:1 [list of integers]: Number of elements in the Y direction. - --nz 4 [list of integers]: Number of elements in the Z direction. - --fields name:support:dim - [name:support:dim ...]: Create fields on CELLS or POINTS, with given dimension (typically 1 or 3). - --cells [bool]: Generate global ids for cells. Defaults to true. - --no-cells [bool]: Don't generate global ids for cells. - --points [bool]: Generate global ids for points. Defaults to true. - --no-points [bool]: Don't generate global ids for points. - --output OUTPUT [string]: The vtk output file destination. - --data-mode binary, ascii - [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. - -``generate_fractures`` -"""""""""""""""""""""" - -For a conformal fracture to be defined in a mesh, ``geos`` requires the mesh to be split at the faces where the fracture gets across the mesh. -The ``generate_fractures`` module will split the mesh and generate the multi-block ``vtk`` files. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py generate_fractures --help - usage: mesh_doctor.py generate_fractures [-h] --policy field, internal_surfaces [--name NAME] [--values VALUES] --output OUTPUT - [--data-mode binary, ascii] [--fractures_output_dir FRACTURES_OUTPUT_DIR] - - options: - -h, --help show this help message and exit - --policy field, internal_surfaces - [string]: The criterion to define the surfaces that will be changed into fracture zones. Possible values are "field, internal_surfaces" - --name NAME [string]: If the "field" policy is selected, defines which field will be considered to define the fractures. - If the "internal_surfaces" policy is selected, defines the name of the attribute will be considered to identify the fractures. - --values VALUES [list of comma separated integers]: If the "field" policy is selected, which changes of the field will be considered as a fracture. - If the "internal_surfaces" policy is selected, list of the fracture attributes. - You can create multiple fractures by separating the values with ':' like shown in this example. - --values 10,12:13,14,16,18:22 will create 3 fractures identified respectively with the values (10,12), (13,14,16,18) and (22). - If no ':' is found, all values specified will be assumed to create only 1 single fracture. - --output OUTPUT [string]: The vtk output file destination. - --data-mode binary, ascii - [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. - --fractures_output_dir FRACTURES_OUTPUT_DIR - [string]: The output directory for the fractures meshes that will be generated from the mesh. - --fractures_data_mode FRACTURES_DATA_MODE - [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. - -``generate_global_ids`` -""""""""""""""""""""""" - -When running ``geos`` in parallel, `global ids` can be used to refer to data across multiple ranks. -The ``generate_global_ids`` can generate `global ids` for the imported ``vtk`` mesh. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py generate_global_ids --help - usage: mesh_doctor.py generate_global_ids [-h] [--cells] [--no-cells] [--points] [--no-points] --output OUTPUT - [--data-mode binary, ascii] - - options: - -h, --help show this help message and exit - --cells [bool]: Generate global ids for cells. Defaults to true. - --no-cells [bool]: Don't generate global ids for cells. - --points [bool]: Generate global ids for points. Defaults to true. - --no-points [bool]: Don't generate global ids for points. - --output OUTPUT [string]: The vtk output file destination. - --data-mode binary, ascii - [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. - -``non_conformal`` -""""""""""""""""" - -This module will detect elements which are close enough (there's a user defined threshold) but which are not in front of each other (another threshold can be defined). -`Close enough` can be defined in terms or proximity of the nodes and faces of the elements. -The angle between two faces can also be precribed. -This module can be a bit time consuming. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py non_conformal --help - usage: mesh_doctor.py non_conformal [-h] [--angle_tolerance 10.0] [--point_tolerance POINT_TOLERANCE] - [--face_tolerance FACE_TOLERANCE] - - options: - -h, --help show this help message and exit - --angle_tolerance 10.0 [float]: angle tolerance in degrees. Defaults to 10.0 - --point_tolerance POINT_TOLERANCE - [float]: tolerance for two points to be considered collocated. - --face_tolerance FACE_TOLERANCE - [float]: tolerance for two faces to be considered "touching". - -``self_intersecting_elements`` -"""""""""""""""""""""""""""""" - -Some meshes can have cells that auto-intersect. -This module will display the elements that have faces intersecting. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py self_intersecting_elements --help - usage: mesh_doctor.py self_intersecting_elements [-h] [--min 2.220446049250313e-16] - - options: - -h, --help show this help message and exit - --min 2.220446049250313e-16 - [float]: The tolerance in the computation. Defaults to your machine precision 2.220446049250313e-16. - -``supported_elements`` -"""""""""""""""""""""" - -``geos`` supports a specific set of elements. -Let's cite the standard elements like `tetrahedra`, `wedges`, `pyramids` or `hexahedra`. -But also prismes up to 11 faces. -``geos`` also supports the generic ``VTK_POLYHEDRON``/``42`` elements, which are converted on the fly into one of the elements just described. - -The ``supported_elements`` check will validate that no unsupported element is included in the input mesh. -It will also verify that the ``VTK_POLYHEDRON`` cells can effectively get converted into a supported type of element. - -.. code-block:: - - $ python src/geos/mesh/doctor/mesh_doctor.py supported_elements --help - usage: mesh_doctor.py supported_elements [-h] [--chunck_size 1] [--nproc 8] - - options: - -h, --help show this help message and exit - --chunck_size 1 [int]: Defaults chunk size for parallel processing to 1 - --nproc 8 [int]: Number of threads used for parallel processing. Defaults to your CPU count 8. - - - -Mesh Conversion --------------------------- - -The `geos-mesh` python package includes tools for converting meshes from common formats (abaqus, etc.) to those that can be read by GEOS (gmsh, vtk). -See :ref:`PythonToolsSetup` for details on setup instructions, and `External Mesh Guidelines `_ for a detailed description of how to use external meshes in GEOS. -The available console scripts for this package and its API are described below. - - -convert_abaqus -^^^^^^^^^^^^^^ - -Compile an xml file with advanced features into a single file that can be read by GEOS. - -.. argparse:: - :module: geos.mesh.conversion.main - :func: build_abaqus_converter_input_parser - :prog: convert_abaqus - - -.. note:: - For vtk format meshes, the user also needs to determine the region ID numbers and names of nodesets to import into GEOS. - The following shows how these could look in an input XML file for a mesh with three regions (*REGIONA*, *REGIONB*, and *REGIONC*) and six nodesets (*xneg*, *xpos*, *yneg*, *ypos*, *zneg*, and *zpos*): - - -.. code-block:: xml - - - - - - - - - - - - -API -^^^ - -.. automodule:: geos.mesh.conversion.abaqus_converter - :members: - - - + ./geos_mesh_docs/home.rst + ./geos_mesh_docs/modules.rst \ No newline at end of file diff --git a/docs/geos_mesh_docs/converter.rst b/docs/geos_mesh_docs/converter.rst new file mode 100644 index 00000000..2b640bb0 --- /dev/null +++ b/docs/geos_mesh_docs/converter.rst @@ -0,0 +1,52 @@ +Mesh Conversion +-------------------------- + +The `geos-mesh` python package includes tools for converting meshes from common formats (abaqus, etc.) to those that can be read by GEOS (gmsh, vtk). +See :ref:`PythonToolsSetup` for details on setup instructions, and `External Mesh Guidelines `_ for a detailed description of how to use external meshes in GEOS. +The available console scripts for this package and its API are described below. + + +convert_abaqus +^^^^^^^^^^^^^^ + +Compile an xml file with advanced features into a single file that can be read by GEOS. + +.. argparse:: + :module: geos.mesh.conversion.main + :func: build_abaqus_converter_input_parser + :prog: convert_abaqus + + +.. note:: + For vtk format meshes, the user also needs to determine the region ID numbers and names of nodesets to import into GEOS. + The following shows how these could look in an input XML file for a mesh with three regions (*REGIONA*, *REGIONB*, and *REGIONC*) and six nodesets (*xneg*, *xpos*, *yneg*, *ypos*, *zneg*, and *zpos*): + + +.. code-block:: xml + + + + + + + + + + + + +API +^^^ + +.. automodule:: geos.mesh.conversion.abaqus_converter + :members: + + diff --git a/docs/geos_mesh_docs/doctor.rst b/docs/geos_mesh_docs/doctor.rst new file mode 100644 index 00000000..0da26c1e --- /dev/null +++ b/docs/geos_mesh_docs/doctor.rst @@ -0,0 +1,284 @@ +Mesh Doctor +--------------- + +``mesh-doctor`` is a ``python`` executable that can be used through the command line to perform various checks, validations, and tiny fixes to the ``vtk`` mesh that are meant to be used in ``geos``. +``mesh-doctor`` is organized as a collection of modules with their dedicated sets of options. +The current page will introduce those modules, but the details and all the arguments can be retrieved by using the ``--help`` option for each module. + +Modules +^^^^^^^ + +To list all the modules available through ``mesh-doctor``, you can simply use the ``--help`` option, which will list all available modules as well as a quick summary. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py --help + usage: mesh_doctor.py [-h] [-v] [-q] -i VTK_MESH_FILE + {collocated_nodes,element_volumes,fix_elements_orderings,generate_cube,generate_fractures,generate_global_ids,non_conformal,self_intersecting_elements,supported_elements} + ... + + Inspects meshes for GEOSX. + + positional arguments: + {collocated_nodes,element_volumes,fix_elements_orderings,generate_cube,generate_fractures,generate_global_ids,non_conformal,self_intersecting_elements,supported_elements} + Modules + collocated_nodes + Checks if nodes are collocated. + element_volumes + Checks if the volumes of the elements are greater than "min". + fix_elements_orderings + Reorders the support nodes for the given cell types. + generate_cube + Generate a cube and its fields. + generate_fractures + Splits the mesh to generate the faults and fractures. [EXPERIMENTAL] + generate_global_ids + Adds globals ids for points and cells. + non_conformal + Detects non conformal elements. [EXPERIMENTAL] + self_intersecting_elements + Checks if the faces of the elements are self intersecting. + supported_elements + Check that all the elements of the mesh are supported by GEOSX. + + options: + -h, --help + show this help message and exit + -v Use -v 'INFO', -vv for 'DEBUG'. Defaults to 'WARNING'. + -q Use -q to reduce the verbosity of the output. + -i VTK_MESH_FILE, --vtk-input-file VTK_MESH_FILE + + Note that checks are dynamically loaded. + An option may be missing because of an unloaded module. + Increase verbosity (-v, -vv) to get full information. + +Then, if you are interested in a specific module, you can ask for its documentation using the ``mesh-doctor module_name --help`` pattern. +For example + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py collocated_nodes --help + usage: mesh_doctor.py collocated_nodes [-h] --tolerance TOLERANCE + + options: + -h, --help show this help message and exit + --tolerance TOLERANCE [float]: The absolute distance between two nodes for them to be considered collocated. + +``mesh-doctor`` loads its module dynamically. +If a module can't be loaded, ``mesh-doctor`` will proceed and try to load other modules. +If you see a message like + +.. code-block:: bash + + [1970-04-14 03:07:15,625][WARNING] Could not load module "collocated_nodes": No module named 'vtkmodules' + +then most likely ``mesh-doctor`` could not load the ``collocated_nodes`` module, because the ``vtk`` python package was not found. +Thereafter, the documentation for module ``collocated_nodes`` will not be displayed. +You can solve this issue by installing the dependencies of ``mesh-doctor`` defined in its ``requirements.txt`` file (``python -m pip install -r requirements.txt``). + +Here is a list and brief description of all the modules available. + +``collocated_nodes`` +"""""""""""""""""""" + +Displays the neighboring nodes that are closer to each other than a prescribed threshold. +It is not uncommon to define multiple nodes for the exact same position, which will typically be an issue for ``geos`` and should be fixed. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py collocated_nodes --help + usage: mesh_doctor.py collocated_nodes [-h] --tolerance TOLERANCE + + options: + -h, --help show this help message and exit + --tolerance TOLERANCE [float]: The absolute distance between two nodes for them to be considered collocated. + +``element_volumes`` +""""""""""""""""""" + +Computes the volumes of all the cells and displays the ones that are below a prescribed threshold. +Cells with negative volumes will typically be an issue for ``geos`` and should be fixed. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py element_volumes --help + usage: mesh_doctor.py element_volumes [-h] --min 0.0 + + options: + -h, --help show this help message and exit + --min 0.0 [float]: The minimum acceptable volume. Defaults to 0.0. + +``fix_elements_orderings`` +"""""""""""""""""""""""""" + +It sometimes happens that an exported mesh does not abide by the ``vtk`` orderings. +The ``fix_elements_orderings`` module can rearrange the nodes of given types of elements. +This can be convenient if you cannot regenerate the mesh. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py fix_elements_orderings --help + usage: mesh_doctor.py fix_elements_orderings [-h] [--Hexahedron 1,6,5,4,7,0,2,3] [--Prism5 8,2,0,7,6,9,5,1,4,3] + [--Prism6 11,2,8,10,5,0,9,7,6,1,4,3] [--Pyramid 3,4,0,2,1] + [--Tetrahedron 2,0,3,1] [--Voxel 1,6,5,4,7,0,2,3] + [--Wedge 3,5,4,0,2,1] --output OUTPUT [--data-mode binary, ascii] + + options: + -h, --help show this help message and exit + --Hexahedron 1,6,5,4,7,0,2,3 + [list of integers]: node permutation for "Hexahedron". + --Prism5 8,2,0,7,6,9,5,1,4,3 + [list of integers]: node permutation for "Prism5". + --Prism6 11,2,8,10,5,0,9,7,6,1,4,3 + [list of integers]: node permutation for "Prism6". + --Pyramid 3,4,0,2,1 [list of integers]: node permutation for "Pyramid". + --Tetrahedron 2,0,3,1 [list of integers]: node permutation for "Tetrahedron". + --Voxel 1,6,5,4,7,0,2,3 [list of integers]: node permutation for "Voxel". + --Wedge 3,5,4,0,2,1 [list of integers]: node permutation for "Wedge". + --output OUTPUT [string]: The vtk output file destination. + --data-mode binary, ascii + [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. + +``generate_cube`` +""""""""""""""""" + +This module conveniently generates cubic meshes in ``vtk``. +It can also generate fields with simple values. +This tool can also be useful to generate a trial mesh that will later be refined or customized. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py generate_cube --help + usage: mesh_doctor.py generate_cube [-h] [--x 0:1.5:3] [--y 0:5:10] [--z 0:1] [--nx 2:2] [--ny 1:1] [--nz 4] + [--fields name:support:dim [name:support:dim ...]] [--cells] [--no-cells] + [--points] [--no-points] --output OUTPUT [--data-mode binary, ascii] + + options: + -h, --help show this help message and exit + --x 0:1.5:3 [list of floats]: X coordinates of the points. + --y 0:5:10 [list of floats]: Y coordinates of the points. + --z 0:1 [list of floats]: Z coordinates of the points. + --nx 2:2 [list of integers]: Number of elements in the X direction. + --ny 1:1 [list of integers]: Number of elements in the Y direction. + --nz 4 [list of integers]: Number of elements in the Z direction. + --fields name:support:dim + [name:support:dim ...]: Create fields on CELLS or POINTS, with given dimension (typically 1 or 3). + --cells [bool]: Generate global ids for cells. Defaults to true. + --no-cells [bool]: Don't generate global ids for cells. + --points [bool]: Generate global ids for points. Defaults to true. + --no-points [bool]: Don't generate global ids for points. + --output OUTPUT [string]: The vtk output file destination. + --data-mode binary, ascii + [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. + +``generate_fractures`` +"""""""""""""""""""""" + +For a conformal fracture to be defined in a mesh, ``geos`` requires the mesh to be split at the faces where the fracture gets across the mesh. +The ``generate_fractures`` module will split the mesh and generate the multi-block ``vtk`` files. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py generate_fractures --help + usage: mesh_doctor.py generate_fractures [-h] --policy field, internal_surfaces [--name NAME] [--values VALUES] --output OUTPUT + [--data-mode binary, ascii] [--fractures_output_dir FRACTURES_OUTPUT_DIR] + + options: + -h, --help show this help message and exit + --policy field, internal_surfaces + [string]: The criterion to define the surfaces that will be changed into fracture zones. Possible values are "field, internal_surfaces" + --name NAME [string]: If the "field" policy is selected, defines which field will be considered to define the fractures. + If the "internal_surfaces" policy is selected, defines the name of the attribute will be considered to identify the fractures. + --values VALUES [list of comma separated integers]: If the "field" policy is selected, which changes of the field will be considered as a fracture. + If the "internal_surfaces" policy is selected, list of the fracture attributes. + You can create multiple fractures by separating the values with ':' like shown in this example. + --values 10,12:13,14,16,18:22 will create 3 fractures identified respectively with the values (10,12), (13,14,16,18) and (22). + If no ':' is found, all values specified will be assumed to create only 1 single fracture. + --output OUTPUT [string]: The vtk output file destination. + --data-mode binary, ascii + [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. + --fractures_output_dir FRACTURES_OUTPUT_DIR + [string]: The output directory for the fractures meshes that will be generated from the mesh. + --fractures_data_mode FRACTURES_DATA_MODE + [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. + +``generate_global_ids`` +""""""""""""""""""""""" + +When running ``geos`` in parallel, `global ids` can be used to refer to data across multiple ranks. +The ``generate_global_ids`` can generate `global ids` for the imported ``vtk`` mesh. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py generate_global_ids --help + usage: mesh_doctor.py generate_global_ids [-h] [--cells] [--no-cells] [--points] [--no-points] --output OUTPUT + [--data-mode binary, ascii] + + options: + -h, --help show this help message and exit + --cells [bool]: Generate global ids for cells. Defaults to true. + --no-cells [bool]: Don't generate global ids for cells. + --points [bool]: Generate global ids for points. Defaults to true. + --no-points [bool]: Don't generate global ids for points. + --output OUTPUT [string]: The vtk output file destination. + --data-mode binary, ascii + [string]: For ".vtu" output format, the data mode can be binary or ascii. Defaults to binary. + +``non_conformal`` +""""""""""""""""" + +This module will detect elements which are close enough (there's a user defined threshold) but which are not in front of each other (another threshold can be defined). +`Close enough` can be defined in terms or proximity of the nodes and faces of the elements. +The angle between two faces can also be precribed. +This module can be a bit time consuming. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py non_conformal --help + usage: mesh_doctor.py non_conformal [-h] [--angle_tolerance 10.0] [--point_tolerance POINT_TOLERANCE] + [--face_tolerance FACE_TOLERANCE] + + options: + -h, --help show this help message and exit + --angle_tolerance 10.0 [float]: angle tolerance in degrees. Defaults to 10.0 + --point_tolerance POINT_TOLERANCE + [float]: tolerance for two points to be considered collocated. + --face_tolerance FACE_TOLERANCE + [float]: tolerance for two faces to be considered "touching". + +``self_intersecting_elements`` +"""""""""""""""""""""""""""""" + +Some meshes can have cells that auto-intersect. +This module will display the elements that have faces intersecting. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py self_intersecting_elements --help + usage: mesh_doctor.py self_intersecting_elements [-h] [--min 2.220446049250313e-16] + + options: + -h, --help show this help message and exit + --min 2.220446049250313e-16 + [float]: The tolerance in the computation. Defaults to your machine precision 2.220446049250313e-16. + +``supported_elements`` +"""""""""""""""""""""" + +``geos`` supports a specific set of elements. +Let's cite the standard elements like `tetrahedra`, `wedges`, `pyramids` or `hexahedra`. +But also prismes up to 11 faces. +``geos`` also supports the generic ``VTK_POLYHEDRON``/``42`` elements, which are converted on the fly into one of the elements just described. + +The ``supported_elements`` check will validate that no unsupported element is included in the input mesh. +It will also verify that the ``VTK_POLYHEDRON`` cells can effectively get converted into a supported type of element. + +.. code-block:: + + $ python src/geos/mesh/doctor/mesh_doctor.py supported_elements --help + usage: mesh_doctor.py supported_elements [-h] [--chunck_size 1] [--nproc 8] + + options: + -h, --help show this help message and exit + --chunck_size 1 [int]: Defaults chunk size for parallel processing to 1 + --nproc 8 [int]: Number of threads used for parallel processing. Defaults to your CPU count 8. \ No newline at end of file diff --git a/docs/geos_mesh_docs/home.rst b/docs/geos_mesh_docs/home.rst new file mode 100644 index 00000000..78cffacb --- /dev/null +++ b/docs/geos_mesh_docs/home.rst @@ -0,0 +1,4 @@ +Home +======== + +**geos-mesh** is a Python package that contains several tools and utilities to handle processing and quality checks of meshes. \ No newline at end of file diff --git a/docs/geos_mesh_docs/io.rst b/docs/geos_mesh_docs/io.rst new file mode 100644 index 00000000..26ece9d3 --- /dev/null +++ b/docs/geos_mesh_docs/io.rst @@ -0,0 +1,12 @@ +Input/Outputs +^^^^^^^^^^^^^^^^ + +`vtkIO` module of `geos-mesh` package contains generic methods to read and write different format of VTK meshes. + +geos.mesh.io.vtkIO module +-------------------------------------- + +.. automodule:: geos.mesh.io.vtkIO + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/geos_mesh_docs/modules.rst b/docs/geos_mesh_docs/modules.rst new file mode 100644 index 00000000..fa6a3558 --- /dev/null +++ b/docs/geos_mesh_docs/modules.rst @@ -0,0 +1,14 @@ +GEOS Mesh tools +=================== + + +.. toctree:: + :maxdepth: 5 + + doctor + + converter + + io + + utils \ No newline at end of file diff --git a/docs/geos_mesh_docs/utils.rst b/docs/geos_mesh_docs/utils.rst new file mode 100644 index 00000000..62c15c72 --- /dev/null +++ b/docs/geos_mesh_docs/utils.rst @@ -0,0 +1,49 @@ +Mesh utilities +^^^^^^^^^^^^^^^^ + +The `utils` module of `geos-mesh` package contains different utilities methods for VTK meshes. + + +geos.mesh.utils.genericHelpers module +-------------------------------------- + +.. automodule:: geos.mesh.utils.genericHelpers + :members: + :undoc-members: + :show-inheritance: + + +geos.mesh.utils.arrayHelpers module +-------------------------------------- + +.. automodule:: geos.mesh.utils.arrayHelpers + :members: + :undoc-members: + :show-inheritance: + + +geos.mesh.utils.arrayModifiers module +---------------------------------------- + +.. automodule:: geos.mesh.utils.arrayModifiers + :members: + :undoc-members: + :show-inheritance: + + +geos.mesh.utils.multiblockHelpers module +--------------------------------------------------------------- + +.. automodule:: geos.mesh.utils.multiblockHelpers + :members: + :undoc-members: + :show-inheritance: + + +geos.mesh.utils.multiblockModifiers module +--------------------------------------------------------------- + +.. automodule:: geos.mesh.utils.multiblockModifiers + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/geos_posp_docs/modules.rst b/docs/geos_posp_docs/modules.rst index 99fcad60..cf77644b 100644 --- a/docs/geos_posp_docs/modules.rst +++ b/docs/geos_posp_docs/modules.rst @@ -6,6 +6,4 @@ Processing filters - processing - pyvistaTools diff --git a/docs/geos_posp_docs/processing.rst b/docs/geos_posp_docs/processing.rst deleted file mode 100644 index d82e7361..00000000 --- a/docs/geos_posp_docs/processing.rst +++ /dev/null @@ -1,20 +0,0 @@ -Processing functions -==================== - -This package define functions to process data. - -geos_posp.processing.multiblockInpectorTreeFunctions module ---------------------------------------------------------------- - -.. automodule:: geos_posp.processing.multiblockInpectorTreeFunctions - :members: - :undoc-members: - :show-inheritance: - -geos_posp.processing.vtkUtils module ----------------------------------------- - -.. automodule:: geos_posp.processing.vtkUtils - :members: - :undoc-members: - :show-inheritance: diff --git a/geos-mesh/pyproject.toml b/geos-mesh/pyproject.toml index 2317c68b..1a184bf8 100644 --- a/geos-mesh/pyproject.toml +++ b/geos-mesh/pyproject.toml @@ -25,11 +25,12 @@ classifiers = [ requires-python = ">=3.10" dependencies = [ - "vtk >= 9.3", + "vtk == 9.3", "networkx >= 2.4", "tqdm >= 4.67", "numpy >= 2.2", "meshio >= 5.3", + "pandas", ] [project.scripts] @@ -56,9 +57,16 @@ test = [ ] [tool.pytest.ini_options] -addopts = [ - "--import-mode=importlib", -] -pythonpath = [ - "src", -] +addopts="--import-mode=importlib" +console_output_style = "count" +pythonpath = ["src"] +python_classes = "Test" +python_files = "test*.py" +python_functions = "test*" +testpaths = ["tests"] +norecursedirs = "bin" +filterwarnings = [] + +[tool.coverage.run] +branch = true +source = ["src/geos"] \ No newline at end of file diff --git a/geos-mesh/src/geos/mesh/doctor/checks/check_fractures.py b/geos-mesh/src/geos/mesh/doctor/checks/check_fractures.py index a42ef418..91375e47 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/check_fractures.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/check_fractures.py @@ -8,7 +8,7 @@ from vtkmodules.vtkIOXML import vtkXMLMultiBlockDataReader from vtkmodules.util.numpy_support import vtk_to_numpy from geos.mesh.doctor.checks.generate_fractures import Coordinates3D -from geos.mesh.vtk.helpers import vtk_iter +from geos.mesh.utils.genericHelpers import vtk_iter @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/collocated_nodes.py b/geos-mesh/src/geos/mesh/doctor/checks/collocated_nodes.py index 91632b3e..74cbbe8c 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/collocated_nodes.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/collocated_nodes.py @@ -5,7 +5,7 @@ from typing import Collection, Iterable from vtkmodules.vtkCommonCore import reference, vtkPoints from vtkmodules.vtkCommonDataModel import vtkIncrementalOctreePointLocator -from geos.mesh.vtk.io import read_mesh +from geos.mesh.io.vtkIO import read_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/element_volumes.py b/geos-mesh/src/geos/mesh/doctor/checks/element_volumes.py index 55ad3a22..3a37375f 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/element_volumes.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/element_volumes.py @@ -5,7 +5,7 @@ from vtkmodules.vtkCommonDataModel import VTK_HEXAHEDRON, VTK_PYRAMID, VTK_TETRA, VTK_WEDGE from vtkmodules.vtkFiltersVerdict import vtkCellSizeFilter, vtkMeshQuality from vtkmodules.util.numpy_support import vtk_to_numpy -from geos.mesh.vtk.io import read_mesh +from geos.mesh.io.vtkIO import read_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/fix_elements_orderings.py b/geos-mesh/src/geos/mesh/doctor/checks/fix_elements_orderings.py index 079377b9..26c958dc 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/fix_elements_orderings.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/fix_elements_orderings.py @@ -1,8 +1,8 @@ from dataclasses import dataclass from typing import Dict, FrozenSet, List, Set from vtkmodules.vtkCommonCore import vtkIdList -from geos.mesh.vtk.helpers import to_vtk_id_list -from geos.mesh.vtk.io import VtkOutput, read_mesh, write_mesh +from geos.mesh.utils.genericHelpers import to_vtk_id_list +from geos.mesh.io.vtkIO import VtkOutput, read_mesh, write_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/generate_cube.py b/geos-mesh/src/geos/mesh/doctor/checks/generate_cube.py index 4b4c71fb..5abd17f1 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/generate_cube.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/generate_cube.py @@ -7,7 +7,7 @@ from vtkmodules.vtkCommonDataModel import ( vtkCellArray, vtkHexahedron, vtkRectilinearGrid, vtkUnstructuredGrid, VTK_HEXAHEDRON ) from geos.mesh.doctor.checks.generate_global_ids import __build_global_ids -from geos.mesh.vtk.io import VtkOutput, write_mesh +from geos.mesh.io.vtkIO import VtkOutput, write_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/generate_fractures.py b/geos-mesh/src/geos/mesh/doctor/checks/generate_fractures.py index bf6f961c..17198237 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/generate_fractures.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/generate_fractures.py @@ -13,8 +13,9 @@ from vtkmodules.util.numpy_support import numpy_to_vtk, vtk_to_numpy from vtkmodules.util.vtkConstants import VTK_ID_TYPE from geos.mesh.doctor.checks.vtk_polyhedron import FaceStream -from geos.mesh.vtk.helpers import has_invalid_field, to_vtk_id_list, vtk_iter -from geos.mesh.vtk.io import VtkOutput, read_mesh, write_mesh +from geos.mesh.utils.arrayHelpers import has_invalid_field +from geos.mesh.utils.genericHelpers import to_vtk_id_list, vtk_iter +from geos.mesh.io.vtkIO import VtkOutput, read_mesh, write_mesh """ TypeAliases cannot be used with Python 3.9. A simple assignment like described there will be used: https://docs.python.org/3/library/typing.html#typing.TypeAlias:~:text=through%20simple%20assignment%3A-,Vector%20%3D%20list%5Bfloat%5D,-Or%20marked%20with diff --git a/geos-mesh/src/geos/mesh/doctor/checks/generate_global_ids.py b/geos-mesh/src/geos/mesh/doctor/checks/generate_global_ids.py index 6142ad7c..2fdcfe27 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/generate_global_ids.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/generate_global_ids.py @@ -1,7 +1,7 @@ from dataclasses import dataclass import logging from vtkmodules.vtkCommonCore import vtkIdTypeArray -from geos.mesh.vtk.io import VtkOutput, read_mesh, write_mesh +from geos.mesh.io.vtkIO import VtkOutput, read_mesh, write_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/non_conformal.py b/geos-mesh/src/geos/mesh/doctor/checks/non_conformal.py index 5d99b433..e4037dac 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/non_conformal.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/non_conformal.py @@ -14,8 +14,8 @@ from vtkmodules.vtkFiltersModeling import vtkCollisionDetectionFilter, vtkLinearExtrusionFilter from geos.mesh.doctor.checks import reorient_mesh from geos.mesh.doctor.checks import triangle_distance -from geos.mesh.vtk.helpers import vtk_iter -from geos.mesh.vtk.io import read_mesh +from geos.mesh.utils.genericHelpers import vtk_iter +from geos.mesh.io.vtkIO import read_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/reorient_mesh.py b/geos-mesh/src/geos/mesh/doctor/checks/reorient_mesh.py index 11134a40..aca4c7ee 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/reorient_mesh.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/reorient_mesh.py @@ -8,7 +8,7 @@ vtkUnstructuredGrid, vtkTetra ) from vtkmodules.vtkFiltersCore import vtkTriangleFilter from geos.mesh.doctor.checks.vtk_polyhedron import FaceStream, build_face_to_face_connectivity_through_edges -from geos.mesh.vtk.helpers import to_vtk_id_list +from geos.mesh.utils.genericHelpers import to_vtk_id_list def __compute_volume( mesh_points: vtkPoints, face_stream: FaceStream ) -> float: diff --git a/geos-mesh/src/geos/mesh/doctor/checks/self_intersecting_elements.py b/geos-mesh/src/geos/mesh/doctor/checks/self_intersecting_elements.py index 18370492..0cad78b4 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/self_intersecting_elements.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/self_intersecting_elements.py @@ -3,7 +3,7 @@ from vtkmodules.util.numpy_support import vtk_to_numpy from vtkmodules.vtkFiltersGeneral import vtkCellValidator from vtkmodules.vtkCommonCore import vtkOutputWindow, vtkFileOutputWindow -from geos.mesh.vtk.io import read_mesh +from geos.mesh.io.vtkIO import read_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/supported_elements.py b/geos-mesh/src/geos/mesh/doctor/checks/supported_elements.py index affad387..2a1c8061 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/supported_elements.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/supported_elements.py @@ -11,8 +11,8 @@ VTK_PENTAGONAL_PRISM, VTK_POLYHEDRON, VTK_PYRAMID, VTK_TETRA, VTK_VOXEL, VTK_WEDGE ) from geos.mesh.doctor.checks.vtk_polyhedron import build_face_to_face_connectivity_through_edges, FaceStream -from geos.mesh.vtk.helpers import vtk_iter -from geos.mesh.vtk.io import read_mesh +from geos.mesh.utils.genericHelpers import vtk_iter +from geos.mesh.io.vtkIO import read_mesh @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/checks/vtk_polyhedron.py b/geos-mesh/src/geos/mesh/doctor/checks/vtk_polyhedron.py index 1cf1929d..8e628a66 100644 --- a/geos-mesh/src/geos/mesh/doctor/checks/vtk_polyhedron.py +++ b/geos-mesh/src/geos/mesh/doctor/checks/vtk_polyhedron.py @@ -3,7 +3,7 @@ import networkx from typing import Collection, Dict, FrozenSet, Iterable, List, Sequence, Tuple from vtkmodules.vtkCommonCore import vtkIdList -from geos.mesh.vtk.helpers import vtk_iter +from geos.mesh.utils.genericHelpers import vtk_iter @dataclass( frozen=True ) diff --git a/geos-mesh/src/geos/mesh/doctor/parsing/generate_fractures_parsing.py b/geos-mesh/src/geos/mesh/doctor/parsing/generate_fractures_parsing.py index 949b47a4..18206a4e 100644 --- a/geos-mesh/src/geos/mesh/doctor/parsing/generate_fractures_parsing.py +++ b/geos-mesh/src/geos/mesh/doctor/parsing/generate_fractures_parsing.py @@ -1,7 +1,7 @@ import os from geos.mesh.doctor.checks.generate_fractures import Options, Result, FracturePolicy from geos.mesh.doctor.parsing import vtk_output_parsing, GENERATE_FRACTURES -from geos.mesh.vtk.io import VtkOutput +from geos.mesh.io.vtkIO import VtkOutput __POLICY = "policy" __FIELD_POLICY = "field" diff --git a/geos-mesh/src/geos/mesh/doctor/parsing/vtk_output_parsing.py b/geos-mesh/src/geos/mesh/doctor/parsing/vtk_output_parsing.py index 47b6eb31..d98d8bcf 100644 --- a/geos-mesh/src/geos/mesh/doctor/parsing/vtk_output_parsing.py +++ b/geos-mesh/src/geos/mesh/doctor/parsing/vtk_output_parsing.py @@ -1,7 +1,7 @@ import os.path import logging import textwrap -from geos.mesh.vtk.io import VtkOutput +from geos.mesh.io.vtkIO import VtkOutput __OUTPUT_FILE = "output" __OUTPUT_BINARY_MODE = "data-mode" diff --git a/geos-posp/src/geos_posp/processing/__init__.py b/geos-mesh/src/geos/mesh/io/__init__.py similarity index 100% rename from geos-posp/src/geos_posp/processing/__init__.py rename to geos-mesh/src/geos/mesh/io/__init__.py diff --git a/geos-mesh/src/geos/mesh/vtk/io.py b/geos-mesh/src/geos/mesh/io/vtkIO.py similarity index 85% rename from geos-mesh/src/geos/mesh/vtk/io.py rename to geos-mesh/src/geos/mesh/io/vtkIO.py index 5d3e3693..aa4e4015 100644 --- a/geos-mesh/src/geos/mesh/vtk/io.py +++ b/geos-mesh/src/geos/mesh/io/vtkIO.py @@ -1,3 +1,7 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Alexandre Benedicto + import os.path import logging from dataclasses import dataclass @@ -8,6 +12,12 @@ vtkXMLStructuredGridReader, vtkXMLPUnstructuredGridReader, vtkXMLPStructuredGridReader, vtkXMLStructuredGridWriter ) +__doc__ = """ +Input and Ouput methods for VTK meshes: + - VTK, VTU, VTS, PVTU, PVTS readers + - VTK, VTS, VTU writers +""" + @dataclass( frozen=True ) class VtkOutput: @@ -81,11 +91,18 @@ def __read_pvtu( vtk_input_file: str ) -> Optional[ vtkUnstructuredGrid ]: def read_mesh( vtk_input_file: str ) -> vtkPointSet: - """ - Read the vtk file and builds either an unstructured grid or a structured grid from it. - :param vtk_input_file: The file name. The extension will be used to guess the file format. - If the first guess fails, the other available readers will be tried. - :return: A vtkPointSet. + """Read vtk file and build either an unstructured grid or a structured grid from it. + + Args: + vtk_input_file (str): The file name. Extension will be used to guess file format\ + If first guess fails, other available readers will be tried. + + Raises: + ValueError: Invalid file path error + ValueError: No appropriate reader available for the file format + + Returns: + vtkPointSet: Mesh read """ if not os.path.exists( vtk_input_file ): err_msg: str = f"Invalid file path. Could not read \"{vtk_input_file}\"." @@ -142,14 +159,20 @@ def __write_vtu( mesh: vtkUnstructuredGrid, output: str, toBinary: bool = False def write_mesh( mesh: vtkPointSet, vtk_output: VtkOutput, canOverwrite: bool = False ) -> int: - """ - Writes the mesh to disk. - Nothing will be done if the file already exists. - :param mesh: The grid to write. - :param vtk_output: Where to write. The file extension will be used to select the VTK file format. - :return: 0 in case of success. - """ + """Write mesh to disk. + Nothing is done if file already exists. + + Args: + mesh (vtkPointSet): Grid to write + vtk_output (VtkOutput): File path. File extension will be used to select VTK file format + canOverwrite (bool, optional): Authorize overwriting the file. Defaults to False. + Raises: + ValueError: Invalid VTK format. + + Returns: + int: 0 if success + """ if os.path.exists( vtk_output.output ) and canOverwrite: logging.error( f"File \"{vtk_output.output}\" already exists, nothing done." ) return 1 diff --git a/geos-mesh/src/geos/mesh/utils/__init__.py b/geos-mesh/src/geos/mesh/utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/geos-mesh/src/geos/mesh/utils/arrayHelpers.py b/geos-mesh/src/geos/mesh/utils/arrayHelpers.py new file mode 100644 index 00000000..2ca957fa --- /dev/null +++ b/geos-mesh/src/geos/mesh/utils/arrayHelpers.py @@ -0,0 +1,672 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Martin Lemay, Paloma Martinez +from copy import deepcopy +import logging +import numpy as np +import numpy.typing as npt +import pandas as pd # type: ignore[import-untyped] +import vtkmodules.util.numpy_support as vnp +from typing import Optional, Union, cast +from vtkmodules.util.numpy_support import vtk_to_numpy +from vtkmodules.vtkCommonCore import vtkDataArray, vtkDoubleArray, vtkPoints +from vtkmodules.vtkCommonDataModel import ( vtkUnstructuredGrid, vtkFieldData, vtkMultiBlockDataSet, vtkDataSet, + vtkCompositeDataSet, vtkDataObject, vtkPointData, vtkCellData, + vtkDataObjectTreeIterator, vtkPolyData ) +from vtkmodules.vtkFiltersCore import vtkCellCenters +from geos.mesh.utils.multiblockHelpers import ( getBlockElementIndexesFlatten, getBlockFromFlatIndex ) + +__doc__ = """ +ArrayHelpers module contains several utilities methods to get information on arrays in VTK datasets. + +These methods include: + - array getters, with conversion into numpy array or pandas dataframe + - boolean functions to check whether an array is present in the dataset + - bounds getter for vtu and multiblock datasets +""" + + +def has_invalid_field( mesh: vtkUnstructuredGrid, invalid_fields: list[ str ] ) -> bool: + """Checks if a mesh contains at least a data arrays within its cell, field or point data + having a certain name. If so, returns True, else False. + + Args: + mesh (vtkUnstructuredGrid): An unstructured mesh. + invalid_fields (list[str]): Field name of an array in any data from the data. + + Returns: + bool: True if one field found, else False. + """ + # Check the cell data fields + cell_data = mesh.GetCellData() + for i in range( cell_data.GetNumberOfArrays() ): + if cell_data.GetArrayName( i ) in invalid_fields: + logging.error( f"The mesh contains an invalid cell field name '{cell_data.GetArrayName( i )}'." ) + return True + # Check the field data fields + field_data = mesh.GetFieldData() + for i in range( field_data.GetNumberOfArrays() ): + if field_data.GetArrayName( i ) in invalid_fields: + logging.error( f"The mesh contains an invalid field name '{field_data.GetArrayName( i )}'." ) + return True + # Check the point data fields + point_data = mesh.GetPointData() + for i in range( point_data.GetNumberOfArrays() ): + if point_data.GetArrayName( i ) in invalid_fields: + logging.error( f"The mesh contains an invalid point field name '{point_data.GetArrayName( i )}'." ) + return True + return False + + +def getFieldType( data: vtkFieldData ) -> str: + """A vtk grid can contain 3 types of field data: + - vtkFieldData (parent class) + - vtkCellData (inheritance of vtkFieldData) + - vtkPointData (inheritance of vtkFieldData) + + The goal is to return whether the data is "vtkFieldData", "vtkCellData" or "vtkPointData". + + Args: + data (vtkFieldData) + + Returns: + str: "vtkFieldData", "vtkCellData" or "vtkPointData" + """ + if not data.IsA( "vtkFieldData" ): + raise ValueError( f"data '{data}' entered is not a vtkFieldData object." ) + if data.IsA( "vtkCellData" ): + return "vtkCellData" + elif data.IsA( "vtkPointData" ): + return "vtkPointData" + else: + return "vtkFieldData" + + +def getArrayNames( data: vtkFieldData ) -> list[ str ]: + """Get the names of all arrays stored in a "vtkFieldData", "vtkCellData" or "vtkPointData". + + Args: + data (vtkFieldData) + + Returns: + list[ str ]: The array names in the order that they are stored in the field data. + """ + if not data.IsA( "vtkFieldData" ): + raise ValueError( f"data '{data}' entered is not a vtkFieldData object." ) + return [ data.GetArrayName( i ) for i in range( data.GetNumberOfArrays() ) ] + + +def getArrayByName( data: vtkFieldData, name: str ) -> Optional[ vtkDataArray ]: + """Get the vtkDataArray corresponding to the given name. + + Args: + data (vtkFieldData) + name (str) + + Returns: + Optional[ vtkDataArray ]: The vtkDataArray associated with the name given. None if not found. + """ + if data.HasArray( name ): + return data.GetArray( name ) + logging.warning( f"No array named '{name}' was found in '{data}'." ) + return None + + +def getCopyArrayByName( data: vtkFieldData, name: str ) -> Optional[ vtkDataArray ]: + """Get the copy of a vtkDataArray corresponding to the given name. + + Args: + data (vtkFieldData) + name (str) + + Returns: + Optional[ vtkDataArray ]: The copy of the vtkDataArray associated with the name given. None if not found. + """ + dataArray: Optional[ vtkDataArray ] = getArrayByName( data, name ) + if dataArray is not None: + return deepcopy( dataArray ) + return None + + +def getNumpyGlobalIdsArray( data: Union[ vtkCellData, vtkPointData ] ) -> Optional[ npt.NDArray[ np.int64 ] ]: + """Get a numpy array of the GlobalIds. + + Args: + data (Union[ vtkCellData, vtkPointData ]) + + Returns: + Optional[ npt.NDArray[ np.int64 ] ]: The numpy array of GlobalIds. + """ + global_ids: Optional[ vtkDataArray ] = data.GetGlobalIds() + if global_ids is None: + logging.warning( "No GlobalIds array was found." ) + return None + return vtk_to_numpy( global_ids ) + + +def getNumpyArrayByName( data: vtkFieldData, name: str, sorted: bool = False ) -> Optional[ npt.NDArray ]: + """Get the numpy array of a given vtkDataArray found by its name. + If sorted is selected, this allows the option to reorder the values wrt GlobalIds. If not GlobalIds was found, + no reordering will be perform. + + Args: + data (vtkFieldData) + name (str) + sorted (bool, optional): Sort the output array with the help of GlobalIds. Defaults to False. + + Returns: + Optional[ npt.NDArray ] + """ + dataArray: Optional[ vtkDataArray ] = getArrayByName( data, name ) + if dataArray is not None: + arr: Optional[ npt.NDArray ] = vtk_to_numpy( dataArray ) + if sorted: + fieldType: str = getFieldType( data ) + if fieldType in [ "vtkCellData", "vtkPointData" ]: + sortArrayByGlobalIds( data, arr ) + return arr + return None + + +def getAttributeSet( object: Union[ vtkMultiBlockDataSet, vtkDataSet ], onPoints: bool ) -> set[ str ]: + """Get the set of all attributes from an object on points or on cells. + + Args: + object (Any): object where to find the attributes. + onPoints (bool): True if attributes are on points, False if they are on + cells. + + Returns: + set[str]: set of attribute names present in input object. + """ + attributes: dict[ str, int ] + if isinstance( object, vtkMultiBlockDataSet ): + attributes = getAttributesFromMultiBlockDataSet( object, onPoints ) + elif isinstance( object, vtkDataSet ): + attributes = getAttributesFromDataSet( object, onPoints ) + else: + raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) + + assert attributes is not None, "Attribute list is undefined." + + return set( attributes.keys() ) if attributes is not None else set() + + +def getAttributesWithNumberOfComponents( + object: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataSet, vtkDataObject ], + onPoints: bool, +) -> dict[ str, int ]: + """Get the dictionnary of all attributes from object on points or cells. + + Args: + object (Any): object where to find the attributes. + onPoints (bool): True if attributes are on points, False if they are on + cells. + + Returns: + dict[str, int]: dictionnary where keys are the names of the attributes + and values the number of components. + + """ + attributes: dict[ str, int ] + if isinstance( object, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): + attributes = getAttributesFromMultiBlockDataSet( object, onPoints ) + elif isinstance( object, vtkDataSet ): + attributes = getAttributesFromDataSet( object, onPoints ) + else: + raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) + return attributes + + +def getAttributesFromMultiBlockDataSet( object: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], + onPoints: bool ) -> dict[ str, int ]: + """Get the dictionnary of all attributes of object on points or on cells. + + Args: + object (vtkMultiBlockDataSet | vtkCompositeDataSet): object where to find + the attributes. + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + dict[str, int]: Dictionnary of the names of the attributes as keys, and + number of components as values. + + """ + attributes: dict[ str, int ] = {} + # initialize data object tree iterator + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( object ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + dataSet: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + blockAttributes: dict[ str, int ] = getAttributesFromDataSet( dataSet, onPoints ) + for attributeName, nbComponents in blockAttributes.items(): + if attributeName not in attributes: + attributes[ attributeName ] = nbComponents + + iter.GoToNextItem() + return attributes + + +def getAttributesFromDataSet( object: vtkDataSet, onPoints: bool ) -> dict[ str, int ]: + """Get the dictionnary of all attributes of a vtkDataSet on points or cells. + + Args: + object (vtkDataSet): object where to find the attributes. + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + dict[str, int]: list of the names of the attributes. + """ + attributes: dict[ str, int ] = {} + data: Union[ vtkPointData, vtkCellData ] + sup: str = "" + if onPoints: + data = object.GetPointData() + sup = "Point" + else: + data = object.GetCellData() + sup = "Cell" + assert data is not None, f"{sup} data was not recovered." + + nbAttributes: int = data.GetNumberOfArrays() + for i in range( nbAttributes ): + attributeName: str = data.GetArrayName( i ) + attribute: vtkDataArray = data.GetArray( attributeName ) + assert attribute is not None, f"Attribut {attributeName} is null" + nbComponents: int = attribute.GetNumberOfComponents() + attributes[ attributeName ] = nbComponents + return attributes + + +def isAttributeInObject( object: Union[ vtkMultiBlockDataSet, vtkDataSet ], attributeName: str, + onPoints: bool ) -> bool: + """Check if an attribute is in the input object. + + Args: + object (vtkMultiBlockDataSet | vtkDataSet): input object + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute is in the table, False otherwise + """ + if isinstance( object, vtkMultiBlockDataSet ): + return isAttributeInObjectMultiBlockDataSet( object, attributeName, onPoints ) + elif isinstance( object, vtkDataSet ): + return isAttributeInObjectDataSet( object, attributeName, onPoints ) + else: + raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) + + +def isAttributeInObjectMultiBlockDataSet( object: vtkMultiBlockDataSet, attributeName: str, onPoints: bool ) -> bool: + """Check if an attribute is in the input object. + + Args: + object (vtkMultiBlockDataSet): input multiblock object + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute is in the table, False otherwise + """ + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( object ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + dataSet: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + if isAttributeInObjectDataSet( dataSet, attributeName, onPoints ): + return True + iter.GoToNextItem() + return False + + +def isAttributeInObjectDataSet( object: vtkDataSet, attributeName: str, onPoints: bool ) -> bool: + """Check if an attribute is in the input object. + + Args: + object (vtkDataSet): input object + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute is in the table, False otherwise + """ + data: Union[ vtkPointData, vtkCellData ] + sup: str = "" + if onPoints: + data = object.GetPointData() + sup = "Point" + else: + data = object.GetCellData() + sup = "Cell" + assert data is not None, f"{sup} data was not recovered." + return bool( data.HasArray( attributeName ) ) + + +def getArrayInObject( object: vtkDataSet, attributeName: str, onPoints: bool ) -> npt.NDArray[ np.float64 ]: + """Return the numpy array corresponding to input attribute name in table. + + Args: + object (PointSet or UnstructuredGrid): input object + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + ArrayLike[float]: the array corresponding to input attribute name. + """ + array: vtkDoubleArray = getVtkArrayInObject( object, attributeName, onPoints ) + nparray: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( array ) # type: ignore[no-untyped-call] + return nparray + + +def getVtkArrayInObject( object: vtkDataSet, attributeName: str, onPoints: bool ) -> vtkDoubleArray: + """Return the array corresponding to input attribute name in table. + + Args: + object (PointSet or UnstructuredGrid): input object + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + vtkDoubleArray: the vtk array corresponding to input attribute name. + """ + assert isAttributeInObject( object, attributeName, onPoints ), f"{attributeName} is not in input object." + return object.GetPointData().GetArray( attributeName ) if onPoints else object.GetCellData().GetArray( + attributeName ) + + +def getNumberOfComponents( + dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataSet ], + attributeName: str, + onPoints: bool, +) -> int: + """Get the number of components of attribute attributeName in dataSet. + + Args: + dataSet (vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataSet): + dataSet where the attribute is. + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + int: number of components. + """ + if isinstance( dataSet, vtkDataSet ): + return getNumberOfComponentsDataSet( dataSet, attributeName, onPoints ) + elif isinstance( dataSet, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): + return getNumberOfComponentsMultiBlock( dataSet, attributeName, onPoints ) + else: + raise AssertionError( "Object type is not managed." ) + + +def getNumberOfComponentsDataSet( dataSet: vtkDataSet, attributeName: str, onPoints: bool ) -> int: + """Get the number of components of attribute attributeName in dataSet. + + Args: + dataSet (vtkDataSet): dataSet where the attribute is. + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + int: number of components. + """ + array: vtkDoubleArray = getVtkArrayInObject( dataSet, attributeName, onPoints ) + return array.GetNumberOfComponents() + + +def getNumberOfComponentsMultiBlock( + dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], + attributeName: str, + onPoints: bool, +) -> int: + """Get the number of components of attribute attributeName in dataSet. + + Args: + dataSet (vtkMultiBlockDataSet | vtkCompositeDataSet): multi block data Set where the attribute is. + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + int: number of components. + """ + elementaryBlockIndexes: list[ int ] = getBlockElementIndexesFlatten( dataSet ) + for blockIndex in elementaryBlockIndexes: + block: vtkDataSet = cast( vtkDataSet, getBlockFromFlatIndex( dataSet, blockIndex ) ) + if isAttributeInObject( block, attributeName, onPoints ): + array: vtkDoubleArray = getVtkArrayInObject( block, attributeName, onPoints ) + return array.GetNumberOfComponents() + return 0 + + +def getComponentNames( + dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataSet, vtkDataObject ], + attributeName: str, + onPoints: bool, +) -> tuple[ str, ...]: + """Get the name of the components of attribute attributeName in dataSet. + + Args: + dataSet (vtkDataSet | vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataObject): dataSet + where the attribute is. + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + tuple[str,...]: names of the components. + + """ + if isinstance( dataSet, vtkDataSet ): + return getComponentNamesDataSet( dataSet, attributeName, onPoints ) + elif isinstance( dataSet, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): + return getComponentNamesMultiBlock( dataSet, attributeName, onPoints ) + else: + raise AssertionError( "Object type is not managed." ) + + +def getComponentNamesDataSet( dataSet: vtkDataSet, attributeName: str, onPoints: bool ) -> tuple[ str, ...]: + """Get the name of the components of attribute attributeName in dataSet. + + Args: + dataSet (vtkDataSet): dataSet where the attribute is. + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + tuple[str,...]: names of the components. + + """ + array: vtkDoubleArray = getVtkArrayInObject( dataSet, attributeName, onPoints ) + componentNames: list[ str ] = list() + if array.GetNumberOfComponents() > 1: + componentNames += [ array.GetComponentName( i ) for i in range( array.GetNumberOfComponents() ) ] + return tuple( componentNames ) + + +def getComponentNamesMultiBlock( + dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], + attributeName: str, + onPoints: bool, +) -> tuple[ str, ...]: + """Get the name of the components of attribute in MultiBlockDataSet. + + Args: + dataSet (vtkMultiBlockDataSet | vtkCompositeDataSet): dataSet where the + attribute is. + attributeName (str): name of the attribute + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + tuple[str,...]: names of the components. + """ + elementaryBlockIndexes: list[ int ] = getBlockElementIndexesFlatten( dataSet ) + for blockIndex in elementaryBlockIndexes: + block: vtkDataSet = cast( vtkDataSet, getBlockFromFlatIndex( dataSet, blockIndex ) ) + if isAttributeInObject( block, attributeName, onPoints ): + return getComponentNamesDataSet( block, attributeName, onPoints ) + return () + + +def getAttributeValuesAsDF( surface: vtkPolyData, attributeNames: tuple[ str, ...] ) -> pd.DataFrame: + """Get attribute values from input surface. + + Args: + surface (vtkPolyData): mesh where to get attribute values + attributeNames (tuple[str,...]): tuple of attribute names to get the values. + + Returns: + pd.DataFrame: DataFrame containing property names as columns. + + """ + nbRows: int = surface.GetNumberOfCells() + data: pd.DataFrame = pd.DataFrame( np.full( ( nbRows, len( attributeNames ) ), np.nan ), columns=attributeNames ) + for attributeName in attributeNames: + if not isAttributeInObject( surface, attributeName, False ): + logging.warning( f"Attribute {attributeName} is not in the mesh." ) + continue + array: npt.NDArray[ np.float64 ] = getArrayInObject( surface, attributeName, False ) + + if len( array.shape ) > 1: + for i in range( array.shape[ 1 ] ): + data[ attributeName + f"_{i}" ] = array[ :, i ] + data.drop( columns=[ attributeName ], inplace=True ) + else: + data[ attributeName ] = array + return data + + +def AsDF( surface: vtkPolyData, attributeNames: tuple[ str, ...] ) -> pd.DataFrame: + """Get attribute values from input surface. + + Args: + surface (vtkPolyData): mesh where to get attribute values + attributeNames (tuple[str,...]): tuple of attribute names to get the values. + + Returns: + pd.DataFrame: DataFrame containing property names as columns. + + """ + nbRows: int = surface.GetNumberOfCells() + data: pd.DataFrame = pd.DataFrame( np.full( ( nbRows, len( attributeNames ) ), np.nan ), columns=attributeNames ) + for attributeName in attributeNames: + if not isAttributeInObject( surface, attributeName, False ): + logging.warning( f"Attribute {attributeName} is not in the mesh." ) + continue + array: npt.NDArray[ np.float64 ] = getArrayInObject( surface, attributeName, False ) + + if len( array.shape ) > 1: + for i in range( array.shape[ 1 ] ): + data[ attributeName + f"_{i}" ] = array[ :, i ] + data.drop( columns=[ attributeName ], inplace=True ) + else: + data[ attributeName ] = array + return data + + +def getBounds( + input: Union[ vtkUnstructuredGrid, + vtkMultiBlockDataSet ] ) -> tuple[ float, float, float, float, float, float ]: + """Get bounds of either single of composite data set. + + Args: + input (Union[vtkUnstructuredGrid, vtkMultiBlockDataSet]): input mesh + + Returns: + tuple[float, float, float, float, float, float]: tuple containing + bounds (xmin, xmax, ymin, ymax, zmin, zmax) + + """ + if isinstance( input, vtkMultiBlockDataSet ): + return getMultiBlockBounds( input ) + else: + return getMonoBlockBounds( input ) + + +def getMonoBlockBounds( input: vtkUnstructuredGrid, ) -> tuple[ float, float, float, float, float, float ]: + """Get boundary box extrema coordinates for a vtkUnstructuredGrid. + + Args: + input (vtkMultiBlockDataSet): input single block mesh + + Returns: + tuple[float, float, float, float, float, float]: tuple containing + bounds (xmin, xmax, ymin, ymax, zmin, zmax) + + """ + return input.GetBounds() + + +def getMultiBlockBounds( input: vtkMultiBlockDataSet, ) -> tuple[ float, float, float, float, float, float ]: + """Get boundary box extrema coordinates for a vtkMultiBlockDataSet. + + Args: + input (vtkMultiBlockDataSet): input multiblock mesh + + Returns: + tuple[float, float, float, float, float, float]: bounds. + + """ + xmin, ymin, zmin = 3 * [ np.inf ] + xmax, ymax, zmax = 3 * [ -1.0 * np.inf ] + blockIndexes: list[ int ] = getBlockElementIndexesFlatten( input ) + for blockIndex in blockIndexes: + block0: vtkDataObject = getBlockFromFlatIndex( input, blockIndex ) + assert block0 is not None, "Mesh is undefined." + block: vtkDataSet = vtkDataSet.SafeDownCast( block0 ) + bounds: tuple[ float, float, float, float, float, float ] = block.GetBounds() + xmin = bounds[ 0 ] if bounds[ 0 ] < xmin else xmin + xmax = bounds[ 1 ] if bounds[ 1 ] > xmax else xmax + ymin = bounds[ 2 ] if bounds[ 2 ] < ymin else ymin + ymax = bounds[ 3 ] if bounds[ 3 ] > ymax else ymax + zmin = bounds[ 4 ] if bounds[ 4 ] < zmin else zmin + zmax = bounds[ 5 ] if bounds[ 5 ] > zmax else zmax + return xmin, xmax, ymin, ymax, zmin, zmax + + +def computeCellCenterCoordinates( mesh: vtkDataSet ) -> vtkDataArray: + """Get the coordinates of Cell center. + + Args: + mesh (vtkDataSet): input surface + + Returns: + vtkPoints: cell center coordinates + """ + assert mesh is not None, "Surface is undefined." + filter: vtkCellCenters = vtkCellCenters() + filter.SetInputDataObject( mesh ) + filter.Update() + output: vtkUnstructuredGrid = filter.GetOutputDataObject( 0 ) + assert output is not None, "Cell center output is undefined." + pts: vtkPoints = output.GetPoints() + assert pts is not None, "Cell center points are undefined." + return pts.GetData() + + +def sortArrayByGlobalIds( data: Union[ vtkCellData, vtkFieldData ], arr: npt.NDArray[ np.int64 ] ) -> None: + """Sort an array following global Ids + + Args: + data (vtkFieldData): Global Ids array + arr (npt.NDArray[ np.int64 ]): Array to sort + """ + globalids: Optional[ npt.NDArray[ np.int64 ] ] = getNumpyGlobalIdsArray( data ) + if globalids is not None: + arr = arr[ np.argsort( globalids ) ] + else: + logging.warning( "No sorting was performed." ) diff --git a/geos-mesh/src/geos/mesh/utils/arrayModifiers.py b/geos-mesh/src/geos/mesh/utils/arrayModifiers.py new file mode 100644 index 00000000..6d9a738c --- /dev/null +++ b/geos-mesh/src/geos/mesh/utils/arrayModifiers.py @@ -0,0 +1,442 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Martin Lemay, Alexandre Benedicto, Paloma Martinez +import numpy as np +import numpy.typing as npt +import vtkmodules.util.numpy_support as vnp +from typing import Union +from vtkmodules.vtkCommonDataModel import ( vtkMultiBlockDataSet, vtkDataSet, vtkPointSet, vtkCompositeDataSet, + vtkDataObject, vtkDataObjectTreeIterator ) +from vtkmodules.vtkFiltersCore import vtkArrayRename, vtkCellCenters, vtkPointDataToCellData +from vtk import ( # type: ignore[import-untyped] + VTK_CHAR, VTK_DOUBLE, VTK_FLOAT, VTK_INT, VTK_UNSIGNED_INT, +) +from vtkmodules.vtkCommonCore import ( + vtkCharArray, + vtkDataArray, + vtkDoubleArray, + vtkFloatArray, + vtkIntArray, + vtkPoints, + vtkUnsignedIntArray, +) +from geos.mesh.utils.arrayHelpers import ( + getComponentNames, + getAttributesWithNumberOfComponents, + getAttributeSet, + getArrayInObject, + isAttributeInObject, +) +from geos.mesh.utils.multiblockHelpers import getBlockElementIndexesFlatten, getBlockFromFlatIndex + +__doc__ = """ +ArrayModifiers contains utilities to process VTK Arrays objects. + +These methods include: + - filling partial VTK arrays with nan values (useful for block merge) + - creation of new VTK array, empty or with a given data array + - transfer from VTK point data to VTK cell data +""" + + +def fillPartialAttributes( + multiBlockMesh: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataObject ], + attributeName: str, + nbComponents: int, + onPoints: bool = False, +) -> bool: + """Fill input partial attribute of multiBlockMesh with nan values. + + Args: + multiBlockMesh (vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataObject): multiBlock + mesh where to fill the attribute + attributeName (str): attribute name + nbComponents (int): number of components + onPoints (bool, optional): Attribute is on Points (False) or + on Cells. + + Defaults to False. + + Returns: + bool: True if calculation successfully ended, False otherwise + """ + componentNames: tuple[ str, ...] = () + if nbComponents > 1: + componentNames = getComponentNames( multiBlockMesh, attributeName, onPoints ) + values: list[ float ] = [ np.nan for _ in range( nbComponents ) ] + createConstantAttribute( multiBlockMesh, values, attributeName, componentNames, onPoints ) + multiBlockMesh.Modified() + return True + + +def fillAllPartialAttributes( + multiBlockMesh: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataObject ], + onPoints: bool = False, +) -> bool: + """Fill all the partial attributes of multiBlockMesh with nan values. + + Args: + multiBlockMesh (vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataObject): + multiBlockMesh where to fill the attribute + onPoints (bool, optional): Attribute is on Points (False) or + on Cells. + + Defaults to False. + + Returns: + bool: True if calculation successfully ended, False otherwise + """ + attributes: dict[ str, int ] = getAttributesWithNumberOfComponents( multiBlockMesh, onPoints ) + for attributeName, nbComponents in attributes.items(): + fillPartialAttributes( multiBlockMesh, attributeName, nbComponents, onPoints ) + multiBlockMesh.Modified() + return True + + +def createEmptyAttribute( + attributeName: str, + componentNames: tuple[ str, ...], + dataType: int, +) -> vtkDataArray: + """Create an empty attribute. + + Args: + attributeName (str): name of the attribute + componentNames (tuple[str,...]): name of the components for vectorial + attributes + dataType (int): data type. + + Returns: + bool: True if the attribute was correctly created + """ + # create empty array + newAttr: vtkDataArray + if dataType == VTK_DOUBLE: + newAttr = vtkDoubleArray() + elif dataType == VTK_FLOAT: + newAttr = vtkFloatArray() + elif dataType == VTK_INT: + newAttr = vtkIntArray() + elif dataType == VTK_UNSIGNED_INT: + newAttr = vtkUnsignedIntArray() + elif dataType == VTK_CHAR: + newAttr = vtkCharArray() + else: + raise ValueError( "Attribute type is unknown." ) + + newAttr.SetName( attributeName ) + newAttr.SetNumberOfComponents( len( componentNames ) ) + if len( componentNames ) > 1: + for i in range( len( componentNames ) ): + newAttr.SetComponentName( i, componentNames[ i ] ) + + return newAttr + + +def createConstantAttribute( + object: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataObject ], + values: list[ float ], + attributeName: str, + componentNames: tuple[ str, ...], + onPoints: bool, +) -> bool: + """Create an attribute with a constant value everywhere if absent. + + Args: + object (vtkDataObject): object (vtkMultiBlockDataSet, vtkDataSet) + where to create the attribute + values ( list[float]): list of values of the attribute for each components + attributeName (str): name of the attribute + componentNames (tuple[str,...]): name of the components for vectorial + attributes + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute was correctly created + """ + if isinstance( object, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): + return createConstantAttributeMultiBlock( object, values, attributeName, componentNames, onPoints ) + elif isinstance( object, vtkDataSet ): + listAttributes: set[ str ] = getAttributeSet( object, onPoints ) + if attributeName not in listAttributes: + return createConstantAttributeDataSet( object, values, attributeName, componentNames, onPoints ) + return True + return False + + +def createConstantAttributeMultiBlock( + multiBlockDataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], + values: list[ float ], + attributeName: str, + componentNames: tuple[ str, ...], + onPoints: bool, +) -> bool: + """Create an attribute with a constant value everywhere if absent. + + Args: + multiBlockDataSet (vtkMultiBlockDataSet | vtkCompositeDataSet): vtkMultiBlockDataSet + where to create the attribute + values (list[float]): list of values of the attribute for each components + attributeName (str): name of the attribute + componentNames (tuple[str,...]): name of the components for vectorial + attributes + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute was correctly created + """ + # initialize data object tree iterator + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( multiBlockDataSet ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + dataSet: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + listAttributes: set[ str ] = getAttributeSet( dataSet, onPoints ) + if attributeName not in listAttributes: + createConstantAttributeDataSet( dataSet, values, attributeName, componentNames, onPoints ) + iter.GoToNextItem() + return True + + +def createConstantAttributeDataSet( + dataSet: vtkDataSet, + values: list[ float ], + attributeName: str, + componentNames: tuple[ str, ...], + onPoints: bool, +) -> bool: + """Create an attribute with a constant value everywhere. + + Args: + dataSet (vtkDataSet): vtkDataSet where to create the attribute + values ( list[float]): list of values of the attribute for each components + attributeName (str): name of the attribute + componentNames (tuple[str,...]): name of the components for vectorial + attributes + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute was correctly created + """ + nbElements: int = ( dataSet.GetNumberOfPoints() if onPoints else dataSet.GetNumberOfCells() ) + nbComponents: int = len( values ) + array: npt.NDArray[ np.float64 ] = np.ones( ( nbElements, nbComponents ) ) + for i, val in enumerate( values ): + array[ :, i ] *= val + createAttribute( dataSet, array, attributeName, componentNames, onPoints ) + return True + + +def createAttribute( + dataSet: vtkDataSet, + array: npt.NDArray[ np.float64 ], + attributeName: str, + componentNames: tuple[ str, ...], + onPoints: bool, +) -> bool: + """Create an attribute from the given array. + + Args: + dataSet (vtkDataSet): dataSet where to create the attribute + array (npt.NDArray[np.float64]): array that contains the values + attributeName (str): name of the attribute + componentNames (tuple[str,...]): name of the components for vectorial + attributes + onPoints (bool): True if attributes are on points, False if they are + on cells. + + Returns: + bool: True if the attribute was correctly created + """ + assert isinstance( dataSet, vtkDataSet ), "Attribute can only be created in vtkDataSet object." + + newAttr: vtkDataArray = vnp.numpy_to_vtk( array, deep=True, array_type=VTK_DOUBLE ) + newAttr.SetName( attributeName ) + + nbComponents: int = newAttr.GetNumberOfComponents() + if nbComponents > 1: + for i in range( nbComponents ): + newAttr.SetComponentName( i, componentNames[ i ] ) + + if onPoints: + dataSet.GetPointData().AddArray( newAttr ) + else: + dataSet.GetCellData().AddArray( newAttr ) + dataSet.Modified() + return True + + +def copyAttribute( + objectFrom: vtkMultiBlockDataSet, + objectTo: vtkMultiBlockDataSet, + attributNameFrom: str, + attributNameTo: str, +) -> bool: + """Copy a cell attribute from objectFrom to objectTo. + + Args: + objectFrom (vtkMultiBlockDataSet): object from which to copy the attribute. + objectTo (vtkMultiBlockDataSet): object where to copy the attribute. + attributNameFrom (str): attribute name in objectFrom. + attributNameTo (str): attribute name in objectTo. + + Returns: + bool: True if copy successfully ended, False otherwise + """ + elementaryBlockIndexesTo: list[ int ] = getBlockElementIndexesFlatten( objectTo ) + elementaryBlockIndexesFrom: list[ int ] = getBlockElementIndexesFlatten( objectFrom ) + + assert elementaryBlockIndexesTo == elementaryBlockIndexesFrom, ( + "ObjectFrom " + "and objectTo do not have the same block indexes." ) + + for index in elementaryBlockIndexesTo: + # get block from initial time step object + blockT0: vtkDataSet = vtkDataSet.SafeDownCast( getBlockFromFlatIndex( objectFrom, index ) ) + assert blockT0 is not None, "Block at initial time step is null." + + # get block from current time step object + block: vtkDataSet = vtkDataSet.SafeDownCast( getBlockFromFlatIndex( objectTo, index ) ) + assert block is not None, "Block at current time step is null." + try: + copyAttributeDataSet( blockT0, block, attributNameFrom, attributNameTo ) + except AssertionError: + # skip attribute if not in block + continue + return True + + +def copyAttributeDataSet( + objectFrom: vtkDataSet, + objectTo: vtkDataSet, + attributNameFrom: str, + attributNameTo: str, +) -> bool: + """Copy a cell attribute from objectFrom to objectTo. + + Args: + objectFrom (vtkDataSet): object from which to copy the attribute. + objectTo (vtkDataSet): object where to copy the attribute. + attributNameFrom (str): attribute name in objectFrom. + attributNameTo (str): attribute name in objectTo. + + Returns: + bool: True if copy successfully ended, False otherwise + """ + # get attribut from initial time step block + npArray: npt.NDArray[ np.float64 ] = getArrayInObject( objectFrom, attributNameFrom, False ) + assert npArray is not None + componentNames: tuple[ str, ...] = getComponentNames( objectFrom, attributNameFrom, False ) + # copy attribut to current time step block + createAttribute( objectTo, npArray, attributNameTo, componentNames, False ) + objectTo.Modified() + return True + + +def renameAttribute( + object: Union[ vtkMultiBlockDataSet, vtkDataSet ], + attributeName: str, + newAttributeName: str, + onPoints: bool, +) -> bool: + """Rename an attribute. + + Args: + object (vtkMultiBlockDataSet): object where the attribute is + attributeName (str): name of the attribute + newAttributeName (str): new name of the attribute + onPoints (bool): True if attributes are on points, False if they are on cells. + + Returns: + bool: True if renaming operation successfully ended. + """ + if isAttributeInObject( object, attributeName, onPoints ): + dim: int = 0 if onPoints else 1 + filter = vtkArrayRename() + filter.SetInputData( object ) + filter.SetArrayName( dim, attributeName, newAttributeName ) + filter.Update() + object.ShallowCopy( filter.GetOutput() ) + else: + return False + return True + + +def createCellCenterAttribute( mesh: Union[ vtkMultiBlockDataSet, vtkDataSet ], cellCenterAttributeName: str ) -> bool: + """Create elementCenter attribute if it does not exist. + + Args: + mesh (vtkMultiBlockDataSet | vtkDataSet): input mesh + cellCenterAttributeName (str): Name of the attribute + + Raises: + TypeError: Raised if input mesh is not a vtkMultiBlockDataSet or a + vtkDataSet. + + Returns: + bool: True if calculation successfully ended, False otherwise. + """ + ret: int = 1 + if isinstance( mesh, vtkMultiBlockDataSet ): + # initialize data object tree iterator + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( mesh ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + block: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + ret *= int( doCreateCellCenterAttribute( block, cellCenterAttributeName ) ) + iter.GoToNextItem() + elif isinstance( mesh, vtkDataSet ): + ret = int( doCreateCellCenterAttribute( mesh, cellCenterAttributeName ) ) + else: + raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) + return bool( ret ) + + +def doCreateCellCenterAttribute( block: vtkDataSet, cellCenterAttributeName: str ) -> bool: + """Create elementCenter attribute in a vtkDataSet if it does not exist. + + Args: + block (vtkDataSet): input mesh that must be a vtkDataSet + cellCenterAttributeName (str): Name of the attribute + + Returns: + bool: True if calculation successfully ended, False otherwise. + """ + if not isAttributeInObject( block, cellCenterAttributeName, False ): + # apply ElementCenter filter + filter: vtkCellCenters = vtkCellCenters() + filter.SetInputData( block ) + filter.Update() + output: vtkPointSet = filter.GetOutputDataObject( 0 ) + assert output is not None, "vtkCellCenters output is null." + # transfer output to ouput arrays + centers: vtkPoints = output.GetPoints() + assert centers is not None, "Center are undefined." + centerCoords: vtkDataArray = centers.GetData() + assert centers is not None, "Center coordinates are undefined." + centerCoords.SetName( cellCenterAttributeName ) + block.GetCellData().AddArray( centerCoords ) + block.Modified() + return True + + +def transferPointDataToCellData( mesh: vtkPointSet ) -> vtkPointSet: + """Transfer point data to cell data. + + Args: + mesh (vtkPointSet): Input mesh. + + Returns: + vtkPointSet: Output mesh where point data were transferred to cells. + + """ + filter = vtkPointDataToCellData() + filter.SetInputDataObject( mesh ) + filter.SetProcessAllArrays( True ) + filter.Update() + return filter.GetOutputDataObject( 0 ) diff --git a/geos-mesh/src/geos/mesh/utils/genericHelpers.py b/geos-mesh/src/geos/mesh/utils/genericHelpers.py new file mode 100644 index 00000000..27005395 --- /dev/null +++ b/geos-mesh/src/geos/mesh/utils/genericHelpers.py @@ -0,0 +1,83 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Martin Lemay, Paloma Martinez +from typing import Any, Iterator, List +from vtkmodules.vtkCommonCore import vtkIdList +from vtkmodules.vtkCommonDataModel import vtkUnstructuredGrid, vtkPolyData, vtkPlane +from vtkmodules.vtkFiltersCore import vtk3DLinearGridPlaneCutter + +__doc__ = """ +Generic VTK utilities. + +These methods include: + - extraction of a surface from a given elevation + - conversion from a list to vtkIdList + - conversion of vtk container into iterable +""" + + +def to_vtk_id_list( data: List[ int ] ) -> vtkIdList: + """Utility function transforming a list of ids into a vtkIdList. + + Args: + data (list[int]): Id list + + Returns: + result (vtkIdList): Vtk Id List corresponding to input data + """ + result = vtkIdList() + result.Allocate( len( data ) ) + for d in data: + result.InsertNextId( d ) + return result + + +def vtk_iter( vtkContainer ) -> Iterator[ Any ]: + """ + Utility function transforming a vtk "container" (e.g. vtkIdList) into an iterable to be used for building built-ins + python containers. + + Args: + vtkContainer: A vtk container + + Returns: + The iterator + """ + if hasattr( vtkContainer, "GetNumberOfIds" ): + for i in range( vtkContainer.GetNumberOfIds() ): + yield vtkContainer.GetId( i ) + elif hasattr( vtkContainer, "GetNumberOfTypes" ): + for i in range( vtkContainer.GetNumberOfTypes() ): + yield vtkContainer.GetCellType( i ) + + +def extractSurfaceFromElevation( mesh: vtkUnstructuredGrid, elevation: float ) -> vtkPolyData: + """Extract surface at a constant elevation from a mesh. + + Args: + mesh (vtkUnstructuredGrid): input mesh + elevation (float): elevation at which to extract the surface + + Returns: + vtkPolyData: output surface + """ + assert mesh is not None, "Input mesh is undefined." + assert isinstance( mesh, vtkUnstructuredGrid ), "Wrong object type" + + bounds: tuple[ float, float, float, float, float, float ] = mesh.GetBounds() + ooX: float = ( bounds[ 0 ] + bounds[ 1 ] ) / 2.0 + ooY: float = ( bounds[ 2 ] + bounds[ 3 ] ) / 2.0 + + # check plane z coordinates against mesh bounds + assert ( elevation <= bounds[ 5 ] ) and ( elevation >= bounds[ 4 ] ), "Plane is out of input mesh bounds." + + plane: vtkPlane = vtkPlane() + plane.SetNormal( 0.0, 0.0, 1.0 ) + plane.SetOrigin( ooX, ooY, elevation ) + + cutter = vtk3DLinearGridPlaneCutter() + cutter.SetInputDataObject( mesh ) + cutter.SetPlane( plane ) + cutter.SetInterpolateAttributes( True ) + cutter.Update() + return cutter.GetOutputDataObject( 0 ) diff --git a/geos-posp/src/geos_posp/processing/multiblockInpectorTreeFunctions.py b/geos-mesh/src/geos/mesh/utils/multiblockHelpers.py similarity index 88% rename from geos-posp/src/geos_posp/processing/multiblockInpectorTreeFunctions.py rename to geos-mesh/src/geos/mesh/utils/multiblockHelpers.py index 189a9a85..ac060f5b 100644 --- a/geos-posp/src/geos_posp/processing/multiblockInpectorTreeFunctions.py +++ b/geos-mesh/src/geos/mesh/utils/multiblockHelpers.py @@ -2,15 +2,17 @@ # SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. # SPDX-FileContributor: Martin Lemay from typing import Union, cast +from vtkmodules.vtkCommonDataModel import ( vtkCompositeDataSet, vtkDataObject, vtkDataObjectTreeIterator, + vtkMultiBlockDataSet ) +from vtkmodules.vtkFiltersExtraction import vtkExtractBlock -from vtkmodules.vtkCommonDataModel import ( - vtkCompositeDataSet, - vtkDataObject, - vtkDataObjectTreeIterator, - vtkMultiBlockDataSet, -) +__doc__ = """ +Functions to explore VTK multiblock datasets. -__doc__ = """Functions to explore and process multiblock inspector tree.""" +Methods include: + - getters for blocks names and indexes + - block extractor +""" def getBlockName( input: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ] ) -> str: @@ -24,7 +26,6 @@ def getBlockName( input: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ] ) -> Returns: str: name of the block in the tree. - """ iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() iter.SetDataSet( input ) @@ -56,7 +57,6 @@ def getBlockNameFromIndex( input: Union[ vtkMultiBlockDataSet, vtkCompositeDataS Returns: str: name of the block in the tree. - """ iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() iter.SetDataSet( input ) @@ -225,3 +225,22 @@ def getBlockFromName( multiBlock: Union[ vtkMultiBlockDataSet, vtkCompositeDataS break iter.GoToNextItem() return block + + +def extractBlock( multiBlockDataSet: vtkMultiBlockDataSet, blockIndex: int ) -> vtkMultiBlockDataSet: + """Extract the block with index blockIndex from multiBlockDataSet. + + Args: + multiBlockDataSet (vtkMultiBlockDataSet): multiblock dataset from which + to extract the block + blockIndex (int): block index to extract + + Returns: + vtkMultiBlockDataSet: extracted block + """ + extractBlockfilter: vtkExtractBlock = vtkExtractBlock() + extractBlockfilter.SetInputData( multiBlockDataSet ) + extractBlockfilter.AddIndex( blockIndex ) + extractBlockfilter.Update() + extractedBlock: vtkMultiBlockDataSet = extractBlockfilter.GetOutput() + return extractedBlock diff --git a/geos-mesh/src/geos/mesh/utils/multiblockModifiers.py b/geos-mesh/src/geos/mesh/utils/multiblockModifiers.py new file mode 100644 index 00000000..ebbf2100 --- /dev/null +++ b/geos-mesh/src/geos/mesh/utils/multiblockModifiers.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Martin Lemay +from typing import Union +from vtkmodules.vtkCommonDataModel import ( vtkCompositeDataSet, vtkDataObjectTreeIterator, vtkMultiBlockDataSet, + vtkUnstructuredGrid ) +from vtkmodules.vtkFiltersCore import vtkAppendDataSets +from geos.mesh.utils.arrayModifiers import fillAllPartialAttributes + +__doc__ = """Contains a method to merge blocks of a VTK multiblock dataset.""" + + +# TODO : fix function for keepPartialAttributes = True +def mergeBlocks( + input: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], + keepPartialAttributes: bool = False, +) -> vtkUnstructuredGrid: + """Merge all blocks of a multi block mesh. + + Args: + input (vtkMultiBlockDataSet | vtkCompositeDataSet ): composite + object to merge blocks + keepPartialAttributes (bool): if True, keep partial attributes after merge. + + Defaults to False. + + Returns: + vtkUnstructuredGrid: merged block object + + """ + if keepPartialAttributes: + fillAllPartialAttributes( input, False ) + fillAllPartialAttributes( input, True ) + + af = vtkAppendDataSets() + af.MergePointsOn() + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( input ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + block: vtkUnstructuredGrid = vtkUnstructuredGrid.SafeDownCast( iter.GetCurrentDataObject() ) + af.AddInputData( block ) + iter.GoToNextItem() + af.Update() + return af.GetOutputDataObject( 0 ) diff --git a/geos-mesh/src/geos/mesh/vtk/__init__.py b/geos-mesh/src/geos/mesh/vtk/__init__.py deleted file mode 100644 index b1cfe267..00000000 --- a/geos-mesh/src/geos/mesh/vtk/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# Empty \ No newline at end of file diff --git a/geos-mesh/src/geos/mesh/vtk/helpers.py b/geos-mesh/src/geos/mesh/vtk/helpers.py deleted file mode 100644 index 94b273da..00000000 --- a/geos-mesh/src/geos/mesh/vtk/helpers.py +++ /dev/null @@ -1,124 +0,0 @@ -import logging -from copy import deepcopy -from numpy import argsort, array -from typing import Iterator, Optional, List -from vtkmodules.util.numpy_support import vtk_to_numpy -from vtkmodules.vtkCommonCore import vtkDataArray, vtkIdList -from vtkmodules.vtkCommonDataModel import vtkUnstructuredGrid, vtkFieldData - - -def to_vtk_id_list( data ) -> vtkIdList: - result = vtkIdList() - result.Allocate( len( data ) ) - for d in data: - result.InsertNextId( d ) - return result - - -def vtk_iter( vtkContainer ) -> Iterator[ any ]: - """ - Utility function transforming a vtk "container" (e.g. vtkIdList) into an iterable to be used for building built-ins - python containers. - :param vtkContainer: A vtk container. - :return: The iterator. - """ - if hasattr( vtkContainer, "GetNumberOfIds" ): - for i in range( vtkContainer.GetNumberOfIds() ): - yield vtkContainer.GetId( i ) - elif hasattr( vtkContainer, "GetNumberOfTypes" ): - for i in range( vtkContainer.GetNumberOfTypes() ): - yield vtkContainer.GetCellType( i ) - - -def has_invalid_field( mesh: vtkUnstructuredGrid, invalid_fields: List[ str ] ) -> bool: - """Checks if a mesh contains at least a data arrays within its cell, field or point data - having a certain name. If so, returns True, else False. - - Args: - mesh (vtkUnstructuredGrid): An unstructured mesh. - invalid_fields (list[str]): Field name of an array in any data from the data. - - Returns: - bool: True if one field found, else False. - """ - # Check the cell data fields - cell_data = mesh.GetCellData() - for i in range( cell_data.GetNumberOfArrays() ): - if cell_data.GetArrayName( i ) in invalid_fields: - logging.error( f"The mesh contains an invalid cell field name '{cell_data.GetArrayName( i )}'." ) - return True - # Check the field data fields - field_data = mesh.GetFieldData() - for i in range( field_data.GetNumberOfArrays() ): - if field_data.GetArrayName( i ) in invalid_fields: - logging.error( f"The mesh contains an invalid field name '{field_data.GetArrayName( i )}'." ) - return True - # Check the point data fields - point_data = mesh.GetPointData() - for i in range( point_data.GetNumberOfArrays() ): - if point_data.GetArrayName( i ) in invalid_fields: - logging.error( f"The mesh contains an invalid point field name '{point_data.GetArrayName( i )}'." ) - return True - return False - - -def getFieldType( data: vtkFieldData ) -> str: - if not data.IsA( "vtkFieldData" ): - raise ValueError( f"data '{data}' entered is not a vtkFieldData object." ) - if data.IsA( "vtkCellData" ): - return "vtkCellData" - elif data.IsA( "vtkPointData" ): - return "vtkPointData" - else: - return "vtkFieldData" - - -def getArrayNames( data: vtkFieldData ) -> List[ str ]: - if not data.IsA( "vtkFieldData" ): - raise ValueError( f"data '{data}' entered is not a vtkFieldData object." ) - return [ data.GetArrayName( i ) for i in range( data.GetNumberOfArrays() ) ] - - -def getArrayByName( data: vtkFieldData, name: str ) -> Optional[ vtkDataArray ]: - if data.HasArray( name ): - return data.GetArray( name ) - logging.warning( f"No array named '{name}' was found in '{data}'." ) - return None - - -def getCopyArrayByName( data: vtkFieldData, name: str ) -> Optional[ vtkDataArray ]: - return deepcopy( getArrayByName( data, name ) ) - - -def getGlobalIdsArray( data: vtkFieldData ) -> Optional[ vtkDataArray ]: - array_names: List[ str ] = getArrayNames( data ) - for name in array_names: - if name.startswith( "Global" ) and name.endswith( "Ids" ): - return getCopyArrayByName( data, name ) - logging.warning( "No GlobalIds array was found." ) - - -def getNumpyGlobalIdsArray( data: vtkFieldData ) -> Optional[ array ]: - return vtk_to_numpy( getGlobalIdsArray( data ) ) - - -def sortArrayByGlobalIds( data: vtkFieldData, arr: array ) -> None: - globalids: array = getNumpyGlobalIdsArray( data ) - if globalids is not None: - arr = arr[ argsort( globalids ) ] - else: - logging.warning( "No sorting was performed." ) - - -def getNumpyArrayByName( data: vtkFieldData, name: str, sorted: bool = False ) -> Optional[ array ]: - arr: array = vtk_to_numpy( getArrayByName( data, name ) ) - if arr is not None: - if sorted: - array_names: List[ str ] = getArrayNames( data ) - sortArrayByGlobalIds( data, arr, array_names ) - return arr - return None - - -def getCopyNumpyArrayByName( data: vtkFieldData, name: str, sorted: bool = False ) -> Optional[ array ]: - return deepcopy( getNumpyArrayByName( data, name, sorted=sorted ) ) diff --git a/geos-mesh/tests/conftest.py b/geos-mesh/tests/conftest.py new file mode 100644 index 00000000..56a1de08 --- /dev/null +++ b/geos-mesh/tests/conftest.py @@ -0,0 +1,54 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Paloma Martinez +# SPDX-License-Identifier: Apache 2.0 +# ruff: noqa: E402 # disable Module level import not at top of file +import os +import pytest +from typing import Union +import numpy as np +import numpy.typing as npt + +from vtkmodules.vtkCommonDataModel import vtkDataSet, vtkMultiBlockDataSet, vtkPolyData +from vtkmodules.vtkIOXML import vtkXMLUnstructuredGridReader, vtkXMLMultiBlockDataReader + + +@pytest.fixture +def arrayExpected( request: pytest.FixtureRequest ) -> npt.NDArray[ np.float64 ]: + reference_data = "data/data.npz" + reference_data_path = os.path.join( os.path.dirname( os.path.realpath( __file__ ) ), reference_data ) + data = np.load( reference_data_path ) + + return data[ request.param ] + + +@pytest.fixture +def arrayTest( request: pytest.FixtureRequest ) -> npt.NDArray[ np.float64 ]: + np.random.seed( 42 ) + array: npt.NDArray[ np.float64 ] = np.random.rand( + request.param, + 3, + ) + return array + + +@pytest.fixture +def dataSetTest() -> Union[ vtkMultiBlockDataSet, vtkPolyData, vtkDataSet ]: + + def _get_dataset( datasetType: str ): + if datasetType == "multiblock": + reader = reader = vtkXMLMultiBlockDataReader() + vtkFilename = "data/displacedFault.vtm" + elif datasetType == "dataset": + reader: vtkXMLUnstructuredGridReader = vtkXMLUnstructuredGridReader() + vtkFilename = "data/domain_res5_id.vtu" + elif datasetType == "polydata": + reader: vtkXMLUnstructuredGridReader = vtkXMLUnstructuredGridReader() + vtkFilename = "data/surface.vtu" + datapath: str = os.path.join( os.path.dirname( os.path.realpath( __file__ ) ), vtkFilename ) + reader.SetFileName( datapath ) + reader.Update() + + return reader.GetOutput() + + return _get_dataset \ No newline at end of file diff --git a/geos-mesh/tests/data/data.npz b/geos-mesh/tests/data/data.npz new file mode 100644 index 00000000..a90e8e07 Binary files /dev/null and b/geos-mesh/tests/data/data.npz differ diff --git a/geos-mesh/tests/data/displacedFault.vtm b/geos-mesh/tests/data/displacedFault.vtm new file mode 100644 index 00000000..2cf49998 --- /dev/null +++ b/geos-mesh/tests/data/displacedFault.vtm @@ -0,0 +1,7 @@ + + + + + + + diff --git a/geos-mesh/tests/data/domain_res5_id.vtu b/geos-mesh/tests/data/domain_res5_id.vtu new file mode 100644 index 00000000..6e29affa --- /dev/null +++ b/geos-mesh/tests/data/domain_res5_id.vtu @@ -0,0 +1,73 @@ + + + + + + + + + + + 18.923530326 + + + 18.923530326 + + + + + + + + + + + 1.7094007438e-15 + + + 1.7094007438e-15 + + + + + + + + + + + + + 37.847060652 + + + 37.847060652 + + + + + + + + + 0 + + + 3221.0246817 + + + + + + + + + + + + + + + _AQAAAACAAADgfwAARhgAAA==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AwAAAACAAACgfwAAdgAAAHcAAAB3AAAAeJztyDENACAMADC8EBJkTA1qmaeF2aA9m/fZcdqM0Vak995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++99957/9EX/I+fp3ic7cgxDQAgDAAwvBASZEzN1DJPZNigPZvZZoxnRZ22I7333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333vuP/gJF6p09eJztyDENACAMALB5ISTImBrUMk9kqOBoz0a0mXXayv2MDO+9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++99/6jvwaTeWc=AQAAAACAAAAwGwAABAEAAA==eJztlksOxDAIQ9PO/e88mq3lZ6JoVKURC5SGfADjUO4xxv1yuUA+BwjF9k95IkenYNX52CsfapNivWVddTTSWrXf+aO66p50ZsZvnV9wD9msbLk67HCajTt9u7WK34ShyythnHhA8VB8Dh/CM+FGOFexJRySn2rbYULcUl4QpitvKPHW2a14f4p0P9T/36ew6nzslY+Z+ubqp+popLVqv/NHddU96cyM3zrvfoh5QRgnHlA8FF/3Q4zpyhtKvHV2K96fIt0P9f/3Kaw6H3vlY6a+ufqpOhpprdrv/FFddU86M+O3zrsfYl4QxokHFA/F1/0QY7ryhhJvnd2K9z/5Ao84Duw=AQAAAACAAACQUQAAMQAAAA==eJztwzENAAAIA7B3SjCBx2lGCG3SbCeqqqqqqqqqqqqqqqqqqqqqqqqqqo8eaqCtmg==AQAAAACAAAAwGwAAIwAAAA==eJztwwENAAAIA6BmJjC67/QgwkZuJ6qqqqqqqvp0AWlKhrc=AQAAAACAAAAwGwAAPQAAAA==eJzt1rEJADAIRUGH/dl/hbSp0oiFcAci2Nm9VFUG5wxPnp3Pfet/AMC87b2ghwCAru29oIcAgK4L9At6fQ==AQAAAACAAABgNgAAawoAAA==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eJztyDENACAMADA8ERLOqUEt87QwG7Rn8z47Tpsx2or03nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvP/oCvK2ftnic7cgxDQAgDAAwPBESzqmZWuaJDBmkPZvZZoxnRZ22I7333nvvvffee++9995777333nvvvf/gLz7+gf8=AgAAAACAAADQPwAAnzAAAG4eAAA=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BQAAAACAAADAOgAATRoAAAgbAAAyGwAAIxoAALEMAAA=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AQAAAACAAADMBgAAFgAAAA==eJzT0hoFo2AUjIJRMAqGNgAA9C4diA==EQAAAACAAADAcAAAVRMAAFMRAADuEQAAZhMAANwTAAD/EgAAqBIAADwRAACTEgAAbRQAAHwTAACZEwAAxBEAACYRAADmEgAAehQAALgQAAA=eJydm2eYVeUVhZ1j7sSSZKzpPeRJ1Bild5AiSEcUpQhEo2joIE0EVFAUUaotCgqCiBUEOwQELIAiIiCKqKiI2GPsIcb8cK15nvPm7svh8Gd/d761115rne+ce4eZ+e5+3/4rqF5R9m1dqPqp6meqj5Wl8Z20uEB1ueoK1StVvxPwu68TcJ5jfKeAjzqXQ49x1H8ldBpHvyvgq3y/NP5W4T6BDusyrp/6/wE+6nSfefsFOM41b7+c+VD/cuj9rnC+7oOFW6r6L+i5FeekvhaXqS4DP3W733PqBzjqMH/9nHnRzzLoNo5+/wFfzGuccA+qfow5S5FXWy0uVr26orQe8ruvbeDP+LYBH3V6/sU586LfZfDF+2qxcP+EDusybrR4rqoordN95h1dKI7jXPOOzpkP9RtnXp6TC4W7W/Uj6FmMc3KiFsNVJ4GfusnvvhODHIz3Pvmo0/OH58yVfo2bFOQ1Srg7VT+EnruRV3Mthvr9BPzUTX73NQ9yML45rotx1On5Q3PmSr/GXRnkdZlwN6l+AD13Iq8OWpyjOhH81E1+93UIcjC+A66LcdTp+efkzJV+jZsYPIemCfc+dFiXcd015wrwUaf7zNu9UBzHuebtnjMf6jfuiuCcXCncQ6rvQc80nJNTtbhE9XLwU7f7Pcf9xFGH+U/NmRf9WOclwNGv+S4P8hruzwGq72LOQ8jrBOekOgH81ON+zzmhUBxHHeY/IWcO9FOpEzj6Nd+E4L6aI9w74Pc84/r68wT4ON995u1bKI7jXPP2zemb+o27bC++l6nuhh76nqB6KXgjPuPpJ6tv6vLcCcBRt/kuDe6PEcI9qvo25niu8U3sW3U8+KmH/O5rEvgzvglyNo46K+fnzIt+jRsfnJOZwu2CjkdxTnprzjjwUaf7zNu7UBzHuebtnTMf6jduXHBOLhVuuepb0DMT56S933f9PAQ/dbvfc9xPHHWYv33OvOjHOq8Ajn7Nd0mQ1xDhblfdiTnLkVcDLQb7+x/wUw/53dcg8Gd8A1wX46jT8wfnzIt+jbs4uK88f4nqm9BT+f8KmjNG9SLwRnxjkO+++qYuzx0DHHWb76LgnPxNuLGqb2DOEpyT6lqcpDoW/NRDfvdVD/wZXx05G0ednn9Szrzo17ixQV7nCXef6uvUg7yqaXGh/YCfut3vOdUKxXHUYf5qOfOiH+u8ELj/81uRxvO+miDcDvB7nnEdNWc0+DjffebtWCiO41zzdszpm/qNGx2ck4uEm6v6GvRMwDlppUV/+wE/dbvfc9xPHHWYv1XOvOjHOvsDR7/muzDIq69wC1RfxZy5yKumFkNUR4GfetzvOTULxXHUYf6aOXOgH+scAhz9mm9UkNfFwk1WbV6R5lmAvFpr0UX1AvBTD/nd1zrwZ3xrXBfjqNPzu+TMi35HgZd5ddfXv5d8W49X/Vz9Z1Sk8VP1+gV94d+qj6lOw/u9+c3j/akBzjrMTxx1me8x5EAfj0GvcfTtfc9nXt2sR/gaSZqnO/KaotfP6gv/BT/9mb87cpoS4KzD/MRlzZV+rPNZ5EW/L8AX3+e6ak5Fkp7TDfMn6/VLmEs/5uuGXCYHOM81L3FZc6R+414KzkkX9X+t83dEkubpinOyVIunVF8FP3Wbvyv8Ly0Ux1mH+YnLmhf9vArdxtHvS/DFvE7XnP2Fr5uk53VBXo9qsV51//LS/szfBTk9GuCsY32Ay5orfTwFvcbRt/fXB3mdpvlVhW/mviTtw/hHtNij+n3w05/5zeP9RwKcdewJcFlzpY/10GscfXt/T5BXZ83/0u/HSZrnNOT1sBarVI8AP/2Z3zzefzjAWceqAJc1V/qxzlXA0e8e+OJz+1TN/2WSntMZz4OHxLMbedGP+dzv/YcCnOfuDnBZc6T+VdBL36eI9ydJuv9U+H5Q/W+CjzrN537vPxjgPPfNAJc1H+rfDb28PzqJ9xvl9OckzXMK7o8HtFir+iX4qdv85vH+AwHOOtYGuKx50c+X0G0c/b4JX8zrZM3/vvCNkvS8Tsjrfi22qh5QXtqf+c3j/fsDnHVsDXBZc6WPtdBrHH17f2uQV0fN/7HwTf3cTtI+jF+ixRuq3wM//ZnfPN5fEuCs440AlzVX+tgKvcbRt/c9n8+hDpr/8yTd3xHPocXq34W86Md87vf+4gDnubsCXNYcqf8N6OU5aS/eL3T+6iVpng44J/dpsdJzy0vrNr95vH9fgLOOlQEua170Y50rgaPfXfDFvNpp/kHCN0jS89ojr0VabPa5gw76M795vL8owFnH5gCXNVf6WAm9xtG39yv97ZfGt9X8w5J0fzvcVwvVvx150Y/53O/9hQHOc7cHuKw5Uv9m6OU5aSPeH/o5kqR52uKc3KvFDtWflpfWbX7zeP/eAGcdOwJc1rzoYzv0Gkff3t8R5NVa838rfKskzdMGed2jxfuqh4Of/sxvHu/fE+Cs4/0AlzVX+tgBvcbRt/c9n/dVK83/UZLub4376m71v4686Md87vf+3QHOc18PcFlzpP73oZfn5CTx/tSfY5I0Tyuck7u02Kn6s/LSus1vHu/fFeCsY2eAy5oXfbwOvcbRt/d3BuekpeaX+T5M0vqNu1P9TyMv+jGf+71/Z4Dz3KcDXNYcqX8n9PKctBDvgf4ck6R5WuKc3KHFJtWflJfWbX7zeP+OAGcdmwJc1rzo42noNY6+vb8pyOtEzf+d8MclaZ4WyGuBFh+ofoX86M/85vH+ggBnHR8EuKy50scm6DWOvr+CP/veX/WVsnSfdXv/dvRTv/vd5/3bAxzzIG5vufG54J+D3ai6HT8Xq/x/V/WfrTpf9QLgyGc8f66W9edv1DUfOoyjbvPND3w30/7RyumPqs7ZuJHCfSqefwW5m8/93h9ZURznuZ8GOOq5HfONo37vfxqc17vE9zJy9f4wNdyG6+x57DduWHA9jB8W8FHHfMw/QDhfv3OFm6q6DXo874aydF9V8XVTnYc51ncW9HGe+6sC53nGVw34qHsedDFn854V5Jz1ejCn25DDgcL5/aCpzmO5ztUf/P2K3wdUff58rt0/Qq+fE//Hqj/UBTlENTr/nm9e748IcNbpecRlve/o17qfQ57Mw74+Bo45ee4heJ9mrt43L+/jJvDdFO87w5E/83B/U+Q6PMAxX+L2dh34/PV9cL3qS7gvjPN9cabqXJzbiO/M4L7Kev9R11zoMI6650EnfZ+gPI5RTr9XbYI8h+n1Z+L5KMjdfE1w/YYFOM81L3HUY76P4Jv6vW9entdrlc+LyNX7vdQwVPPmYh77jesVXA/je+F6GEcdczGfn4unCDdLtVFFmsfzjO+qxbmq51eU1u1+z3E/cdRh/q4586If6zwXOPodCjzzGuT7QfUFzJmFvOppMUB1yF70uN9z6hWK46jD/PVy5kA/1jkAOPo135Agr5HCP6C6BXPmIa+mWlykegtyox73e07TQnEcdZi/ac4c6OcW6DaOfs1nPJ+j04XbDH7PM+4M9d+MnDjffeY9I8BxrnnPyOmb+m+BXn7+7SPcVaqboMf6+uHzbw3xnaY6C3Osvxb0mcdzawQ46vKcGkF+5q0V5Ed/s6B/X68Hc7oZOfB8ef581eehxzjrGaQ6E7wR36DAT1bf1DUTOoyj7lnQyefQUJ9D1Y2Y47nGN9Lib6o3gZ96yO++RoE/4xsFfNR5E/Tsa170OxO+mFd/4RapPgc9tyCv2lqMUr0R/NTtfs+pHeCow/y1c+ZFPzdCt3H0exN88b66RrgN4Pc843qq/+/g43z3mbdngONc8/bM6Zv6b4TeyPdtqs9CD30PVL0BvBHfwMBPVt/UdQN0GEfdf4dO3h/nC3e/6nrM8VzjG2ox1ueyorQe93tOwwBHHeZvmDMH+rHOscDR7w3wxbwuEG6i6jOYcz/yaqbFKarnVZTWQ373NQv8Gd8M18U46vT8U3LmRb/GnRfkNUy4q1Wfhp6JyKuxFqerngt+6na/5zQuFMdRh/kb58yLfqzzdODo13zG8zlk3tmq6zDHOM/po9obvBFfH+S7r36oy3P7AEfd5usdnJPRwj2suhZzZuOctNBinOo54Kce93tOi0JxHHWYv0XOHOjHOscBR7/mOyfIa4xwd6iuwZyHkVdLLc5XPRv81EN+97UM/BnfEtfFOOr0/PNz5kW/xp0d5HWJcDNUn4KeO5BXGy16qP4V/NRNfve1CXIwvg2ui3HU6fk9cuZKv8b9NXgOef49qk9Cj3HWM0L1LPBGfCOQ7776pi7PHQEcdZvvrOCcDBDuctUnMOcenJM6Wpyseib4qYf87qsT+DO+DnI2jjo9/+ScedGvcWcGeQ0U7hHVx6HncuRVV4vxqn8BP3W733PqForjqMP8dXPmRT/WOR44+jXfX4K8xgt3s+pqzHkEebXz50bVXuCnHvK7r13gz/h2uC7GUafnn5czL/o1rlfwHPL8e1VXQY9x1jPS3z+BN+IbiXz31Td1ee5I4KjbfD2DczJJuBWqKzHnXpyTzlpMVJ2EHKjH/Z7TuVAcRx3m75wzB/qZBN3G0a/5jGdejbX/a/28q5aqfw7mn68Zf6sW7/oLOnjRz93Mbx7v31oojrMO8xOX9ed99GOd74KPfj+DL+a1Vbke4t/bTdLzGiOvOVpsUz0SOujP/I2R05wAZx3bAlzWXOnHOrcBR7/vwhfzaqj5ic+Tfw8gSfswfrYWz6geBB30Z37zeH92gLOOZwJc1lzpxzqf4XmF323wxed2A+n8WZKe0xDne7Bev4W86Md87vf+4IriOM99K8BlzZH6jTMvf/5TX7w1ha/v3+P17wEnaZ3uG6TX34i3oI3Dykv78DzzeX9QgLMuzyEua370Y9xh+L0Z5mBf3yBn5mSeQnC+6knPV2WYA50D9Xp1IT2Xvs1XH/kNDHCea17isuZN/caZl8+huur/lX8/2r8HW5bWV/n9jF6/oy8cWl5at/nrwf+AAGcd5icua170sRp6jaNv778T5FVHc6oI3y5J89RFXv31+kN94Ufgpz/z10VO/QOcdZifuKy50sc70GscfXv/wyCv2przG+GrJWmeOsirn16/py/8p1Dan/nrIKd+Ac46zE9c1lzpxzrfw3OIfj+ELz6HamnOv8vSc2pjfl+9fhxz6cd8tZFL3wDnueYlLmuO1G/c48E5qan+/6qveZLmqYVz0kev1+gLPygvrdv8teC/T4CzDvMTlzUv+ngceo2jb++vCfKqoTlHCl89SfPURF7Xa/Ga6teF0v7MXxM5XV8ojrMO8xOXNVf6WAO9xtH31/DH+6q65vynLN1fA/OvU/+T4KMf89VALtcFOM99MsBlzZH6X4NenpNq/v8Afx/m51VZWp/x12qxUfXA8tK6zW8e718b4KxjY4DLmhd9PAm9xtG39zcGeVXV/F/492KTNE815HWNFm+rHgx++jO/ebx/TYCzjrcDXNZc6WMj9BpH3973fN5Xx2v+n5J0f1XcVzPU/znyoh/zud/7MwKc534e4LLmSP1vQy/PyXHiPUD4Y5M0z/E4J9O1eF71C/BTt/nN4/3pAc46ng9wWfOiny+g2zj6/Ry+mNefnYfwJybpecchr2labFCtKC/tz/zm8f60AGcdGwJc1lzpxzo3AEe/z8MX8zpW8w/352R/v5vAh/BTtXhFNYEO+jO/ebw/NcBZxysBLmuu9LEBeo2jb+97Pp9Df9L8HyTp/mPxHJqi/heRF/2Yz/3enxLgPPfFAJc1R+p/BXp5To4R737+PsGfH31/4pxM1mKdall5ad3mN4/3Jwc461gX4LLmRT/WuQ44+n0RvpjX0Zp/qPDtk/S8Y5DX1Vq8rPpj6KA/85vH+1cHOOt4OcBlzZU+1kGvcfTtfc/nfXWU5u8pS/cfjfvqKvU/gbzox3zu9/5VAc5znwhwWXOk/pehl+fkj+I9WPiGSZrnKJyTHnq9xXzlpXWb3zze71FRHGcdWwJc1rzo4wnoNY6+ve/59s2/i/ffJR+VpPf598yfMA8/78qK4yt9BriIz/hPwMf/Zzfef7fpv8vsqtoNfO7j31/77zh/p1qlPJ++yvOdpPGcZxz1ma8KrmvWv0+lf/shjvlUgX/eV8aPU52heg14jDdPW9Ueqj2Rb1Y9xFlH2wBHXVUw3zj66QHdld8HwW9P+Pq/35sSbp7qbeg3zv0DVAcGOvc2P5o7IMBRT0/MN476B0Ivz4nxd6kuVl0CHuPNM0x1tOqYnHqIs45hAY66BmK+cfQzGrqNo98x8MVzYvwa1bXoN87901VnBDr3Nj+aOz3AUc8YzDeO+mdAL30b/4LqVvQb5/7ZqnNyzo/mzg5w1DMD842j/jnQy/vD+FdV31LdBR7jzbNAdaHqopx6iLOOBQGOuuZgvnH0sxC6jaPfRfDFc2L8x34fRb9x7l+quizQubf50dylAY56FmG+cdS/DHr5ucb4z1S/Uv1G1R/QzOc+861QXa261t//5NRHnHWtCHDUtwzzjaO/1dBvHP2vhT/jmM86+Of5Mv4g4Q/2B9/90zj3b1bdEvjZ2/xo7uYARz3rMN846t8CvTxfxh+meqTqL1V/BT73mW+76muqu1X/BzLR5bJ4nJ2df8xWhXmGEfQDnakC6pooCFbAopuAtd0U2GYnP2qzZOI6BQoLKGjQimAnCmKX9A/RtgOliXag1dUfm8Iqra2YqdtsFMV0ii010U1tJ1Zwbadg23XqknlfJ/ku9uQ9nP5zf3qu57nv57znfd/vfZ+vxzf6Bvzf/34YPfgDGXDYoA/0twb1P/6DghsWfangji/6vSGOPkdHX+7r3xeO4yOjP+3rz8NxHH/84CP78adEf0f1cNS/E/1lMU8v/8r3nYJznjfkD+f8v1TeIeH6xH8senp0SnSq+lFHv/ei70cHD47P4G75zJHrvYJzPvrhD+f53ld+OM/PPO+L8/nBD97XF/yM6EzVw1E/LDpc57Otf+U7rOCcZ4j84Zx/uPJGBhwi/pzoedE/Ux94+hwdHRk9vmMec+Q4uuCca7j84TzPSOWG87zHay5fJ/Bzo59VffO6kfqx0XFFzl7+le/YgnOe4+UP5/zjlNdzwy+OXqx6OOonRid19K98Jxac84yTP5zzT1Jezw2/LLpc9XDUT45O6ehf+U4uOOeZJH8455+ivJ4b/troatXDUT89OqOjf+U7veCcZ4r84Zx/hvJ6bvi10XWqh6N+dnROR//Kd3bBOc8M+cM5/xzl9dzwX4v+jerhqL8welFH/8r3woJznjnyh3P+i5TX73/wd0Tvid6rPvD0WRK9IrqsYx5z5FhScM51kfzhPM8Vyg3neZdpLl8n8N+MPqB6OOqvia4scvbyr3yvKTjnWSZ/OOdfqby+TuC/E/3n6L+oDzx9vhC9MfqljnnMkeMLBedcK+UP53luVG44z/slzcXcOTzg3w76QD868AP9yMD+x+9JwdvR/zykvx/11HH8HnH0h3dfc+4H58cbfnZ0TvRU9YGnz4l5woyJ/rqYr1ee5vV2YH/ePnAfUb7K13PAjVE/z81xfH2+4NdHvxpdpD7w9JkXnR+doPPXNg/cej1u9oFzrjHyh/McE5TXvvDz5evzBX9X9O7oRvWBp8/l0aXRxR3zwN2lx80+cM41X/5wnmOx8toXfql8/b4D/63ot1UPR/210dUd/eG+pcfJ/eGcZ6n83Q9+tfr5OoF/Kvp09GH1gafPzdH10S92zAP3lM6/feCca7X84TzHF5XXvvDr5evzBf+j6AvRf1UfePrcEb0zemvHPHA/0uNmHzjnWi9/OM9xq/LaF/5O+fp5Bb8r+rrqm98nU/jN6AMd/eF26XFyfzjnuVP+7gf/gPr5e1X4t3hf5X04+lP1o45+/xh9JPrd6JaO+eDe0uNhv+Z77qLfFnGeZ4vywnn+72o+54N/RPl8fcHzi99Bg/rXw1H/dHR7R384/ODdH855HpG/+8FvVz+/DsGzVzmcz0fqA08f9i87o9/vmAcOf3j7wDnXdvnDeY7vK6994XfK19cJPPuTUT5vA/rXs1/Z3dEfru3+y3l2yt/94Hern68TePYjvxsdrT7w3iv9KrqnYx64tvsr59otfzjPsUd57Qv/K/n6fMGzB/mD6GnqA+9906HRdzvmgWu713Iu+r2rfp6D44eqn+fm+JDiewt49iWfip6lPvDeKx0VPVznr20euLb7K+c6VP5wnuNw5bUv/FHy9fmCZ3/ymeifqg+890+josd2zAPXds/lXEfJH85zHKu89oUfJV+/bsOzd5mn+uZ1KPXsZU7q6A/Xds/lPKPk737wJ6mfrxN49i6XRBeoD7z3UadFT+mYB67t3su5TpI/nOc4RXntC3+afH2+4NnXXBldoj7w3mNNjZ7eMQ9c232Zc50mfzjPcbry2hd+qnx9vuDZ81wXXaE+8N5/zYye1TEPXNs9m3NNlT+c5zhLee0LP1O+Pl/w7Iduit6gPs3fPaQBe6S50fM65oFru59zrpnyh/Mc5ymvfeHnytev2/DskTaovvm+OPXsmRZ19Idru8dznrnydz/4Rern6wSe/dDfRTeqD7z3a8ujizvmgWu7x3OuRfKH8xyLlde+8Mvl6/MFzx5pS/Tv1Qfe+7ZV0Ss75jnQvZ5zLZc/nOe4UnntC79Kvj5f8OzJHo8+qD7w3st9OXpdxzxwbfd/zrVK/nCe4zrltS/8l+XrPeEfHfGBjsn3L2MH9j/+lzn+8xT+Qvss6uhjHm5swVX94DlOP3+PCH9y9OPRz0T/XP2oo98+TkgOjIqO7uuWD4488PaDcz76jdbn049rTuc2x/zMY87nZ7Tm9/MK/sro2ug69YGnz9To7Ogcnd+2ecyRY2rBOddo+Te/P2qe2coN53nnaC6/v8Pfwffmqoejfkn00iJnL//Kd0nBOc8c+Td7B+W/VHl9ncDfy/fnfD+uPvD0WRa9JrqyYx5z5FhWcM51qfyb90nNc41yw3nelZrL5wv+segT0SfVp/m7lvRZE10bXVfk7pXHHDnWFJxzrZQ/nOdZq9xwnned5vL5gt8R/UH0h+oDT58N0duitxe5e+UxR44NBedc6+QP53luU244z3u75vLrEPyPoz9RPRz190c3FTl7+Ve+9xec89wufzjn36S8vk7g90R/xvuw+sDT58HoQ9GtHfOYI8eDBedcm+QP53keUm44z7tVc/l8wf939H+i76oPPH2+F30i+mSRu1cec+T4XsE511b5w3meJ5QbzvM+qbn8vIIfnF+UhwzqX9+8TqTwueiOImcv/8r3uYJzniflD+f8O5TX1wn8h6LHRo9TH3j6vBB9LbqrYx5z5Hih4Jxrh/zhPM9ryg3neXdpLp8v+JOiH42OVx94+rwVfTu6t8jdK485crxVcM61S/5wnudt5YbzvHs1l59X8GdEz1Q9HPUH87l28P+fs5d/5Utfc85Dv0P0Odz5m+PF9xbwfxg9OzrNfQb073NY9IjokTofbfOYI8dhBbdfLvnDeZ4jlBvO8x6puXy+4P8kem50lvrA0+fD0eOiI4rcvfKYI8eHC865jpQ/nOc5TrnhPO8IzeXnFfzs6BzVN6+XqT8xOqbI2cu/8j2x4JxnhPybz8vKP0Z5fZ3A/0X0ougi9Wn+LjoNxkdPjU7omMccOcYXnHONkT+c5zlVueE87wTN5fMFf1l0afQK9YGnzyeiZ0TPLHL3ymOOHJ8oOOeaIH84z3OGcsN53jM1l88X/NXRldFV6tO8zqfBJ6NnR6cVuXvlMUeOTxacc50pfzjPc7Zyw3neaZrLr0PwX4n+teqb19XUnx+9oMjZy7/yPb/gnGea/OGc/wLl9XUCvz56S/RW9YGnz7zogujCjnnMkWNewTnXBfKH8zwLlBvO8y7UXL5O4L8RvUv1cNR/Lnp5kbOXf+X7uYJznoXyh3P+y5XXc8Nvim5WPRz1V0VXdPSvfK8qOOe5XP5wzr9Cef38gP929LHoP6kPPH1WR9dEb+iYxxw5Vhecc62QP5znWaPczfelmvcGzeXrhD0ae6Nx0T59/+A9239Fn9Uein7Uc5x6uLZ7vD7lqnydH45+vk7g2eucH/20+sB7n3ZC9Ji+/n5t88C13duNU77K13Mco7z2hec4vj5f8Ox5bor+lfrAe082N3pOxzxwbfdxznWC/OE8xznKa1/4ufL18wqefdDfqr75vJJC9kWXdfSHa7uPc5658nc/+MvUz9cJPHudLdH71Afee7JV0c93zAPXdh/nXJfJ3xzzOKd9za0srhN49jrbVN/83plC9j436Xy19Ydru3/bolyVr/PfpH6eG559zU7VN9d9CtnnfF3zt/WHa7tH26Zcla/zf139/PyAZz/zH9F/Vx9477E2R+/V+WibB67tvmyn8lW+nuNe5bUv/Gb5+jqBZz/zC9U3v2+lkP3Nwx394dru0Zxns/zdD/5h9fPfI8Gzd3kv+uvoPvWjzvurbdHHo491zAfXdl/mfA/L3xxzOSec539c8zkf/Dbl8/UFz17n0EH965vXlxSy93m+oz9c272a82yTv/vBP69+vr7g2c+MiHLfx2HqR533Xq9HfR/JA83XfG88qD9f7dmc73n5m+t1v0vP/7Lmcz7415XP1xc8e56TVQ/n/di+jv5wbfdvzvO6/N0Pfp/6+fqCZ68zOcp9Hz+mftR5D9YX9X0kDzQfXNu9m/Ptk7+5Xve79PxwffL1+eL4IcXnd3j2QdNVD+e92lCd37b+cG33ds7TJ3/3gx+qfv49Cp49D/dVPEd94L0n830kDzQPXNt9nHMNlb+5Xve79Nwj5evrBJ590FzVN6+DqWdfVN2fspd/8/lWj1O1j2t7X0znH6t+nhuevc5i1cN5P1bdn7KXP1zb/Vvb+2I6/0T189zw7GeWqR7Oe67q/pS9/OHa7tHa3hfT+Sern+eGZ+9yreqb17nUs5ep7k/Zyx+u7T6s7X0xnX+6+nluePYsa1XfvK6lnj1MdX/KXv5wbfdcbe+L6fyz1c9zw7M/+Zrq4bx3qu5P2csfru1eq+19MZ3/QvXz+x88+5O7o3eoD7z3Skuj1f0pe+WBa7u/antfTM+xRHntC79Uvr5O4Nmz/IPq4byHurqjP1zbPZfzLJW/+8FfrX6+TuDZB3H/x++oD7z3T76P5IHmgWu753Kuq+Vvrtf9Lj33jfL1dcI/Hx09JjpY3LPp93L0lehzup6o61OdOfvS91lxzvOc/OGc/xXl9dzwo6KjVQ9H/e7ono7+le/ugnOeV+QP5/x7lNdzw4+Pnqx6OOr3Rvd19K989xac8+yRf/P5V/w+5fXc8L8X/X3Vw1E/MP9i0MHd/Ctf+ppzHvrhD+f8HKev54afEZ2pejjqh0WHa/62/pXvsIJznkHyh3P+4crrueFnRc9TffN9WX4YER3Z0b/yHVFwzjNc/s3nTvEjlXe/z73RudHPqr753JsfxkbHdfSvfMcWnPOMlH/zOVH8OOX13PCLoxerHo76idFJHf0r34kF5zzj5A/n/JOU13PDL4suVz0c9ZOjUzr6V76TC855JskfzvmnKK/nhl8VvVb1cNRPi07v6F/5Tis455kifzjnn668+33ujV4fXaN6OOrPjc7q6F/5nltwzjNd/nDOP0t5PTf8+uhXVQ9H/bzo/I7+le+8gnOeWfKHc/75yuu54W+L3q56OOovjl7S0b/yvbjgnGe+/OGc/xLl9dzwm6KbVd+8ruaHq6IrOvpXvlcVnPNcIn8451+hvJ4b/tHoY6qHo/766JqO/pXv9QXnPCvkD+f8a5TXc8M/FX1a9c3zMT/cHF3f0b/yvbngnGeN/OGcf73yem74HdHnVQ9H/Yboxo7+le+GgnOe9fKHc/6Nyuu54X8c/Ynq4ai/P7qpo3/le3/BOc9G+cM5/ybl9dzwP4v+XPVw1D8U3drRv/J9qOCcZ5P84Zx/q/L6ezn4vdGD8t89GXhQ/z7N/08+fR6Nbo8+0zGPOXI8WnDOtVX+cJ5nu3IfrOP0fUZz+TqBHxodpno46l+MvlTk7OVf+b5YcM7zjPzhnP8l5fXfUcAfFx0dHR89Wf2oo9+u6J7o3ui+jvnMkWtXwTnfS/KH83x7lB/O8+/VfHA+P/s0/37fh4WbHZ2j+ub6zg8n8t/b4X5cB+hf+dLXnPPQb4z+/t/5OU5fX1/wi6KLo7dEb1U/6ug3IToxuiC6UOenbT5z5JpQcM43Rv5wnm+i8sPdUnALCg7/heJ8fcHfx/NA9XDUfz56dzFPL3+4+/R4uj+c8yyUvzn6Oqff5/hnvrf/7ejQ6BDx3me8Gn0xukPfE1PvfYi5tnsT59ohfzjP8aLy2hf+Vfn6fMHzff8J0WPVB957kDejr3XM07zOiq/2Lc71qvzhPMdrymtf+Dfl6+cVPHuCU1QP573JOx39m/c18dVexnnelL/7wb+jfr5O4NkTnBGdqD7w++1Por/pmAeu7Z7Guej3G/XzHM1x9fPcHMfX5wue/cKnon+sPs19TdOHPcRR0Q/p/PXK87+rlyXaeJydnWfQVsUZhkFeEBULNhQxIChiBxGxIgr2aCwYVEQ/goolxcTYYySjY4sxWLBgS8YZZ2LBZJzYJlEnPxJFUWOJoqCxd7HFFktmkvv6Zrjiztn35c+tnGuf53727O45nP2+c3q1evz3T6TH7tGto71yYBVxE6PbRFs5sIK4PcRzfNVCXvhVlbdPj2/mJ0X3UXs42n8rOrDD/HCTxDs+nP2sqvyOBz9Q8Vw3/NTooWoPR/v1oyM6zA83Vbzjw9nPQOV3PPgRird0/r63+KOiR0e/pzjwxNk8Ojq6cYd+4I4S7zxw9jVC+eFcx8by67zwo5XX/QV/fPSn0R8pDjxxto+Oi27doR+448U7D5x9jVZ+ONextfw6L/w45fW8gj89+nO1h6P9rtHdOswPd7p4x4ezn3HK73jwuymexwn8edHzozMVB544+0cnRffo0A/ceeKdB86+dlN+ONexh/w6L/wk5XV/wc+OXhadpTjwxDks2hU9uEM/cLPFOw+cfU1SfjjXcbD8Oi98l/J6XsFfF/2N2sPR/ujoMR3mh7tOvOPD2U+X8jse/DGK53ECPzd6a/S3igNPnJOjp0SP7dAP3FzxzgNnX8coP5zrOFZ+nRf+FOV1f8HfG70v+kfFgSfOedHzo2d06AfuXvHOA2dfpyg/nOs4Q36dF/585XV/wc+LPhj9q+J0r1uJc2l0dnRWh37g5ol3Hjj7Ol/54VzHLPl1XvjZyut1CP7x6BNqD0f7a6LXdpgf7nHxjg9nP7OV3/Hgr1U8jxP4l6IvRxcoDjxxbonOjV7foR+4l8Q7D5x9Xav8cK7jevl1Xvi5yuv+gl8cfS/6huLAE+eu6N3R2zr0A7dYvPPA2ddc5YdzHbfJr/PC3628nlfwS/X8n/bquWR7ONo/FJ3fYX448sE7Ppz93K38jgc/X/E8TuBXjq4S7aM48MRZGF0UfbRDP3Dkh3ceOPuar/xwruNR+XVe+EXK6/6C3yi6cXQ1xYEnzr+iH0ef79AP3EY6b84DZ1+LlB/OdTwvv84L/7Hyur/gp0QPie6lOPDEWS9/MTw6oHdnfuCm6Lw5D5x9EW+AONcxQH6dF57j5O0bro/4K6NzohdGZyoe7Yg3PXp49MDoHh36g7tS59H54OxvuPKboy77hLtQ/eC67M8c/hhfvcQvVDuO0+4G9WdtPriFOp+OCzdHfpzX86p7vYiuEl1VHPpwClsYXRR9LvpIryXjOs/DBc4+iP+wOPt6RPlL9SyS75aOE/c51eX+gh8U/VZ0cMEfcV6Nvh59o+C7yY85fLxa4OzrOeWHcz2vy3dLx4n7hury/RD8iOgGag9H+w+iHxZ8NuUv5f2gwNnPG8oPZ/8fyq/HCfzm0S2jYxUHnjhfsHAkcc9WZ37M4eOLAmdfxCM/nOvhwBeK53p7aqK7v+C3je4S3VVx4InTO7pStL/6rdaPOXz0LnD21VP54VzPSvLd0nHi9lddnlfw+0b3U3s42q8VHVTw2ZS/lHetAmc//ZUfzv4Hya/HCfx3owdHpygOPHGGRNflfq1DP+bwMaTA2dcg5YdzPevKd0vHibue6nJ/wU+PHhE9UnHgibNJdLPoyILvJj/m8LFJgbOv9ZQfzvVsJt8tHSfuSNXleQV/XPTHag9H+22i2xZ8NuUv5d2mwNnPSOWHs/9t5dfjBP7k6KnR0xQHnjg7RSdGd+7Qjzl87FTg7Gtb5YdzPRPlu6XjxN1Zdbm/4M+Mnh09R3HgibNXdJ/ovgXfTX7M4WOvAmdfOys/nOvZR75bOk7cfVWX5xX8xdFL1B6O9odEpxZ8NuUv5T2kwNnPvsoPZ/9T5dfjBP7K6NXRaxQHnjjTo0dGZ3Toxxw+phc4+5qq/HCu50j5buk4cWeoLvcX/O+iN0VvVhx44hwfPSF6YsF3kx9z+Di+wNnXDOWHcz0nyHdLx4l7ouryvIL/U/TPag9H+7Oj5xR8NuUv5T27wNnPicoPZ//nyK/HCfxfon+L3q848MS5IHpR9OIO/ZjDxwUFzr7OUX4413ORfLd0nLgXqy73F/zD0Uejf1cceOJcEZ0Tvargu8mPOXxcUeDs62Llh3M9c+S7pePEvUp1eV7B/zP6gtrD0f7G6E0Fn035S3lvLHD2c5Xyw9n/TfLrcQL/SvTt6DuKA0+cW6O3R+/o0I85fNxa4OzrJuWHcz23y3dLx4l7h+pyf8F/HP0q+rXiwBPnvuj90QcKvpv8mMPHfQXOvu5QfjjXc798t3ScuA+oLvcX/PJ5Pr1CdMWeS8aBJ85T0aejCwq+m/yYw8dTBc6+HlB+ONfztHzDud4FqsvrEPz60RFqD0f796MfFHw25S/lfb/A2c8C5Yez/w/k1+MEftfoZPZ3FAeeOP3zF+tEh/buzI85fBDfnH0Rj/xwrgef/cW53qGqy/0F/+vo7OhligNPnIOih0W71G+1fszh46ACZ19DlR9udiHeYQWOuF3ivG8Hv0DtOE676xt8lfLBOX6X4pojrvN7XaAe9nVW6/HNnPfHno8+quf1tPO+mrna/Tfi4auU1/6fVzzXA89+zRC1h/M+15uqvzY/XO0+GnHwVcpr/28qnuuGZ39mQ7WH8/7VR6q/Nj9c7f4YcfBVymv/Hyme64Znn2UrtYfzftVSrSXj1+aHq90PIw6+SnntH454rhue/ZPd1B7O+04rq/7a/N3XJ/GlfS3i4KuU1/5XVjzXDc9+yf5qD+f9pLVVf21+uNr9KuLgq5TX/tdWPNcNz77HIWoP5/2j4aq/Nj9c7f4UcfBVymv/wxXPdcOznzFD7eG8DzRK9dfmh6vdZyIOvkp57X+U4rluePYvfqL2cN7f2U711+aHq90/Ig6+SnntfzvFc93w7EP8TO3hvJ+zi+qvzQ9Xu19EHHyV8tr/LornuuHZXzhX7eG8L7Of6q/ND1e770McfJXy2v9+iue64dlPuFTt4bzfcqjqr80PV7ufQxx8lfLa/6GK57rh2Re4Vu3hvL9ylOqvzQ9Xu39DHHyV8tr/UYrnuuF53n+L2nevL/kP9gNOUv21+eFq92GIg69SXvs/SfFcNzzP9+9Rezjvf5yr+mvzw9XurxAHX6W89n+u4rlueJ7TP6D23fM2/8Fz/EtUf21+uNr9FOLgq5TX/i9RPNcNz/P3x9QezvsWV6v+2vxwtfsixMFXKa/9X614rhue5+0vqj2c9yNuVv21+eFq9zuIg69SXvu/WfFcNzzPzd9VezjvP9yp+mvzw9XubxAHX6W89n+n4vm5IjzPv3vk+dRHigPv/YR50XvUH7V+4Gr3LYiDv1Je13GP/Dov/Dzl9TiB53n4Sj2XbN89P/MfPC9/psP8cLX7FPYzT/kdD/4ZxfPvm8Dz/HsDnm9HByke7bxf8GH0reirHfqDq92fsL9nlN8cddknnOt/S/XZH/yH8ufxBc9z84PUHs77D8N6d5YfrnZ/w36IN0yc/Q/TvsMy4ZYWz3P0y6OzojOiRyou7b2/MC16cHRUdKT6q9YvXO2+hn0OU35z1GefcDPUH64Lbpb6z/3gOsxRh/dT4BeoHce97zGtzXxwtfspl8uP8/o6x58douOj60dZNuHnpbBlknDZ6Pv5+wf1/Jf2/JlX4OyD+PPE2Rdx3hfnOji+rOa36+Y4+T0fyUvcb0e3j64bXSm6lNrb7+rcf0Tfzd8/E31IdRHP9Zur7Sf7fEj54VwXx98V537g+NLqd/ff6hpHLR0nLnG6+y1/z/ikDnyuGV0x2ku8630puiA6X35o7/4yV9uv9jVf+eFcxwL5dV74l5TX11XyEndlHUftq/R7io47v8DV1o02/X6k/S9UPNfNfVz/6ArRZcQ9lvbPRp+OPq78tOurdub6F7hnxdnP48rvePBPK57nxzLi14gOjC4r3nlfjL4cfUJ+aG/f5mrrs68nlN/xqOfFQjzX+7Lqcn8tF10vul10k2g/8U8mzmLGXRJ/kv//h/zQnjxPFjj7IP6T4uyLOJ+Icz34XCzO9X6iutxf/cTvFJ0QXV68/fVL3OWjT8kP7V2fudp+sC/ikN/xqKefzmtLx7vjtpbk/e9Hxi3zeEB0rejaUcYt7TzPX4i+En1N47p2vWh3PuGXuPYDt5Z4+4VzvS+qHseDf03x/u/f6VGui8Oi/P43v1fO9aP73+m6zr4T9e+d+/frm65H7V7X2/29/qbfj3c/vFPI6356Vf3g+2PWadbX4dEtomOirD+sa7T3+v5e9Kvo11pfvf4Rz9cLc7XXldp11/W+V4jn+herLjj321fqj5aOE/dr9ZfnAfeH3J+Pjm4a5XwzPmjn+/0vo59qPLR7P9ruvy9qx63reUd+nZd++LKQ1/30qfrB10HWL9anzaKc14Hivc59pvPtcdR0H9Puelo7fl3PZ4V4rvc91eV1g/V8aHTj6KjoSMXFB+1Z99+Ofhz9d/Rz5W/3egI3VLzztttP1Elc+4cbJd71wbmfPlP9jgf/ueJ53WD9Zz4xD3gvBu/b4P0jtPP1gnnj93H4/SS172Vpuj7B1b4XpXbdqH2/iPvpC8VzPzNfOH+cn3HRPaOs+7Tz/OJ89o2R1aJfyV/TPG33elQ7/lwXPs25XvJSD5z7h+PE9XrDeWFd3zG6c5T3l/BeFM4f7b3+L5c8K0b9/hS/J6ZpXNRed+Bq30/jevHteLXvg3F/9VY/wLl/OU5+Xz8ZH6xTfF9iYnSceK9f/g5FX/lpWv/aHaf4I659wE0UX/pehuvsK879xX0Mz0n3itLvo8X7uewAnQ+Ph9r7pNrnv7Xj0PXg0/Fc73Kqy/3FesJ6sXf0oOgY8V531ogOi/r+vem+vN31zb6IN0yc68Gn47neYarL1yXmN/P3gCjv7+G9QLwnqfv3arQeDI4OiZbeo1S7rtS+Z8q+Bxfi1b7nqfY9SO6nIeoHX5eY78x/vhvDd1QmRzl/nG/ae53w92bW0Xn2uGhad2qvt3C13/2p/U5O7fh2P62h+p0Xfh3l9TxgfWG9OTB6WJTzzXijndejodENNB7avW7Wrn/tzgPXN7QQz3UPVl1w7qcN1A+eBzwfYb1jneqK/iB6QpTn1LT3cxXWtw2jY6M7RPvIb+1zmtrn6LXrt+vpI5+O19Vjybocj+P011j1Q0vHyb+D+snXT+YN3zXiu0XTopPF+/tPfN9oow7nJVztd6bsax3lh6v9XpPr3Uic1w3uY9jP/k702Cjzg3lHO+93rxkdo/njedm0b97S8ab7K/tesxCvdt1w/WNUX0vHHW9MoZ9Z7znPnJ9jol1R5g/tfH3gfG6h+eL5VXudabrfanec1s5/172h6nJe+C2U1/3Mes96fnh0epT3HnLfQztfHzaN+r2IQ+Sv6T6q3etRu++dpK7S+xvdD5sW8rqfNlE/uJ/Zd+R6wPp8UfRXUfYdaed9WtbzKdHJ0X7y17Tf29Lxpv3Q2uuZ6+gnn45H/VMK8dw/k1W/7zf4eaTx0TnRG6KXR1m3WA9p758vOzx6XHSa1jevm+Rt+nm12p+bch34cbzadd31r6m64Nxf09QPcO7f49Rvnges/1wPvh89Mcq8Yh7SzteLLaPjNe/avV+tvT61uz64nk3l13nphy0Led1P49UP7meuA9zf8B1GvrP4wyjXCdr5/sffbdyqcN1puo+qvT7B1X5Hs/Y7k653C9XjePBbKZ7XG9Z/zjPn56Qo72/lvbBHqL2vG5zXHaN+f6zfp9t0HWrpOPlL7xuuHbfEaXrfb+37cN1vOxbyul93Un95HnRFOe+c11OiZ0T5dxPtfH/FOJgQ3T06Vv5q79M43vTvudpx6zrGyqfjUf+EQjz3z+6q3/+O5Oevfx/9Q5Trw3jx/Fz2qdHTdN1o9+e7zeHj1AJHnKbrqus4XH7hXPdpqs/jkvsj7mtuj94VvTs6Qe18PzUzemb0rKh/7q3p59ngau/f7G955Xc86ptZiOf6z1R9LR0n/1mq3+sz4511ne/t8r3ZmdFfRBn3tPf67+/08h3aPTU/aq8n7c7L2u8l135f2HVPUD1wMxW39J1eOOLuKc7nh/tQ7jOviv4yelaU+x/ul2jv+9cjogdE946W7qtqn1/U3jfX3s+5ri3lF879sLfqg6Pf/gM47p0GeJydm3n4V1Wdx/npFxcUxRCXXMKp0WoKy8wlJzcsBTU1FUJtcR1FEFk0QNkEbQKRtHLJSRABwSkBhdS0FETtmSZMc2lqMjPNtaKpCdz7w/eL5+HVnOeeO/zzevje9/2cz/tz7z3n3HPPb0a3d/6d2HmHZ4ZBt2vC67ttePzUcLP8vkk4LJwWXhpeEn45vFDn7ZN4nwmPCY8KDwkPVn60RzyO7yPdNOndHjrikGepXfs5RPmis/+j5M/5oT9G+W2a37urXeJODceHY6V3fkeHh4WHKh/iE+dQXYe2dSAO+ZXa5Th+nKfbtY52fV+OC6eEV4SzwsvDSTqvf+IdGX4uHBIOCgcoP9ojHsf7SzdFereHzvkNUPuOh7/PFeLZ9yD5Quc6DVEdfF9ODqeHX1OcKdIPTJwTwpMU33kTnzgcHyjddOndTtt64YO4ztc6x0PXI79zfw4Pua5cj7nh7eFt4ZXhBYqzr+5DruewcEJ4cXhyeJDyJx/ic3xf6SZJ7/bREYe8S+3W3t+uz7CCzvU6Wf7Ruc4TVLeOjhP3YtV18/zO80D/RH9+bXhdeFV4WUg/xvkeJ04LTw9PCY9Vf17bP7Ydn4hDvqV27fe0QjziUAf76eg4dbN/dK7v6aqbx4Np4YxwfniT4uGH8xiPmS+NCIervbbjO7oZ0ru9tnW2vxGFePZ9mnyhc52Gqw5+DugH6RevDueEN4bzQsYZznf/+aVwaHhueN7/c/yq7bfROc8hah8dPonr/NHNkd7+0N0ovf1bR57nSefngP4UP5x3c7gwpJ/kPM8XaGdkOKrQj9bOO2r7+drrYR/DlKfj4X9kIZ7rM0r+XWeeK56bW8JF4b+F9F+c5+dwTDg6PEvjQm1/2Pa5Jw55ltrlOL6cp9ulDmMK7bpOo1UHzz/p73hf/Ul4dzhfer/3XhNeqn6NfIhLO6X35tp+13leU4jn/EcoT3T2e6l8+b6kv1gcLg+XhdznPBecR38yLpwUTtRz4OemqX9Ct1h6t9f2ebWfkcoXHf5p3/6sI+5E6Vxn7neuH9dnVbgi5H7nPI+vXM8rwhl6HsivaZxu+xzW3n/2MUZ5Oh7+ryjEc31myL+ff64v1+WB8P5wofS+D2aFMwvjQ1O/3/Z+c16j1L7j4WdWIZ79zpQv35f0q1wv6rwyvCf8d53nfpjrcnl4WXhBy/68o+O0S5zR0tXeb8TBTyk/juPfftyudbTreTDzDq4z1+fx8NfhL0LeNznf8xWu6+xwUTgvnKB8a+c/te/Dtfet/UxQno5HPWYX4rlei1SHjo7T/jzVyc8Bzxf9+n3hg+F/hjxfnOd+f3r4tfBqPX+140fb5558iet80D0ovfNFZ7+z5Mfx0F+teFvkd56HmSHrMqyn3Bk+H74UvhDeEX5P8QanHa/vXBIuDZeFt4VTwsnyQ17k6fgdHScf4gyWrnYdynW4pKBzHSbLDzrXbYr8o3Pdl6p+HR3nuixTfTs6Tvu3qf5+7uhHV4UPh6vDh0L6Wc7zPOC68NrwSo1Htf02ulXSuz10xCHPUrv2d10hHnHwbz/oXKdrVQePP8y3eD94IvxV+EvFJV/O93vEnPDmcL7at6/a+V7T+0vbetrvnEI8+79OvtC5bjerHh0dJ+581cvPAf3oj8PHwv8KnwzpZzmPfvab4Q3hTeGNhX6bdmjXcWr7d3TkS1zng84+rlae6PBNXPuyjrg3Suc6M89gXCMPzn8qZJ7BeZ5HO++FoechTfPxjo43zX9qx+XaOtvvbPlxPPQLFc/9Df0SzxPPwe/C58Knw5/qfPdnPD9LwsXhLeG3WvaPHR2nfeJcK11t/0AcfJXycz2WFOIRh3rZNzrXdbHq5e+O3wqXhj8P14avhf8T/ne4QHHOSPyLwrnhinBVeE+4IDxf+ZMP8Tl+hnRLpXf76Jzv+Wrf8fA/txDP9Vkhv+j+rl7yj871vUf1QufrsUr19fya/Tr4Jo914Rvhn0LGM8ZJ1iOJd6quF35Whg+Gd2scLK1jNu0nQrdAeueBrnb9tPZ+qJ0vuH5zVAe3S/1XFtr1dblb9UXn6/igrofHO/ptxslnwxfDl0P69fXrwhpHbw1vD5cXxomm8bh2PEFHvsR1PujsY6HyRIdv4tqXdcRdLp3rTH/OvO/18M3wzyH9NOd5XvhA+FD4A/Xj5Nc0v2w7zjjvBwrx7GOJ8kRn3z+QL3Su00Oqg+cVzFO4zlyf/w07Xe/w1fyfdSDO9/yG63pvuDq8P1ykfGvnS7XrVLX3rf0sUp6ORz3uLcRzvVarDh0dp/37VSevvzP/4P7g+v81fEV6z1O4T+4Lv6d8muY5HR2nPeIslq72fiYOPkr52e99iud+g35mTbhx6r1JyHXiunIe/dD3w5+EP9V1LPV/pX4N3Rrp3V7b+w1fxHXe6Oz7Xvmyjrj27zovCXtEv0XYPWR+t1TnjU+8x8LHw4fD0nyR9ojH8fEFHXk9VtDVzlPtZ67yRWf/D8sfOtfrcdXDzz/riZtFv2O4efi89KwzPhr+NvxZ6PXF2vVK5/FoQee8lqp9dPbzW+WNzn5/Jl+uF+uzrJdum/N2CLfv2lDvddynwmfC3yif2nVg2rGuFI88nyrEs49nlC86+/yN/Hj8Z52c70l839k057875HpxH3C+923yXeiR8FldV98vTftAOzretJ5f+32s9n52PR4pxHO9nlUd0Lmej6pO7mcZ/5jPbZfzeoZv5XfGR87z/PDp8MnwR+F9yq9pvEVXOx8lDnmW2rW/pwvxiIN/+0HnOj2pOrjf4PsPzyvPzy7hXdJPThw/18+HU5VP7XcmjtMecSZLV9u/OP+pytPx0D+veNxX6ImHftfw+9K5vRfCaWqfeJw/rVDHWj/OZ5radzz0Lyien8e/hN2i7xXuHG4TdnVteN4PE+8/wl+Evwt/Gf5Y+dEO7ToOOo7TLnF+KB35Etf5oOuSn1J+O6sO9oVuG9XJvl1n5qvMS3uHfcK+YUd19vz2V+Gvw5fC1cqv9v2tdj7t/FarfXT4Iq7zRtdHdbAv62j/Jek8/jO+8R7Me+l7cv4/hluGjHOc730gvM++GP4xfKIwHjbtK+noeNM4XPteb58vFnT2/Yj8oHOdnpB/dK7rH1Uvj0u8d/BesXv4D+Fa6f1+siZ8JVyhfGrX4Wvfg5zXCrXvePhZU4hnv6/Il7/DsH7Muu/7ct5Hw4+EO4Wsl7FeRxyvP/8hfD18LXwuLK3v1X7frl3/rl1XtP8/FOK5Dg/IFzrX7TnVAZ3r/brqh87X4zXV1+MB6/583+mX8/YK3xuu03n+XrQufCP8fbhS+dV+d6r9HuG81xXi2cdK5YnOvn8vX+hcpzdUB48H3Adc5/3Cg8I9Q+bXzNs53/fPRumYNg9fze+l+X3T+nXb+7b2vcK+0L1aaJe64M/tul7EoQ7oXF+OE9fPAesqrId8Ijwk/Bjjvs77u3WYxN8ifDO/L5OP2n1qtes+zo94bxbi4Y98Hc++ibOF6uw6rT/O/Rkd9zHzA+ZvzKc+HH4q/OeQcZ3zva7PPGxtuHXa3SR8Ub6avhOgq53H1M5H7Yd4m6iersfaQjzXC99rpXM9aW/rwvVh3Yz7iOu/b3hEuHe4ra6P91Fy33SlvXeFb+V3r7M17cvs6HjT+l7tc2E/xHurEI96dOk5R+c6Eeddut6uK8e7Cv0U8w++q3885/UPB4bMFzjP3+nfDnumnW1Dzydqv/fXzouc99uFePZBvG1VP/vHz9uK5/oQp2ehzswr2M+yT847LDwy7Kc6e38MLxBbhX3Cdcqvdp9N7XzHeZOH49kH8fqozvaPn27SuT595N915n2G95ADwmO7Nmz3NZ3n95/uif9u5dV2nxK62vet2jrbH/k6nn13ky90rhPHuxfqzLyXee3+4XEhz9EbOs/z5I0Tfyc9Z233/6CrnZfX9hv2R76OZ9/E20l1dp04TlyPn6yLM99lnjogPDzcg+dI46fX05nf9k5724R/yu8/l6+eisvxJ6VrWsdHt5XyLbVbO8/fQ3WwH8ejbvh3PNeVeL0LzwHreB8Kjw4/o3kX8zDOY53vr+H2ib+D5l2epzWtG6IjH/Rur+388Gj5dN7o7Jt4O0jnOnF8+0KdWYfie/yh4QnhgeHuqrO/72+Z+LvSTrhGfmv3CdSujzlv8nA8+yDeZqqffW8mX+hcJ45vWagz66esjx4Tfik8ivFBdfZ6646J/8Fwu/BZ+a1dt639buu8ycPx7IN426l+9r2dfKFznThO+14vZn/J58Mv6P5Yf/9Fz76TPfLD+3Ud2+5fsY48iG9d7f1rH1sqX3T2zfE9Cvcl71G8/wwKTww/TT+i+9LvXX0T/z1hr/AZ+ajdx1H7nuf8iNdLdbE/8nU8++4lX+hcJ473LdyXrOewn+ez4akh6zPovc9n5xz4J63bkE/TPiF0tetKzpP2Hc/5d5xnt//bL8eJ6/kZ+0PoR+gnvhger/zIl/O9r4T+5QPhLmrfvmr3ZzXtZ2lbz9r+0/XAl3Wu087yj8513UX18v3MeMB3vIPD0zVOoPf3wB458GH15+RT+z2xdlxynrTvePZBfj2Un33uKD/uZ9lfQj9F/3Ja+Enqrn7W+9fojz7EdQm9/6NpHxy6pn0vbftZ+yDeptLZ96by5XbRc7xXoc678TyEQ8KzwpOYR6jOL6fBP4fvTfyPhO8L/6K60A7tOg663dQucV6Wbojydz7oPig/pfzOUh3sC91JqpN9+/nfRdfvjPDMkP1E6H0f9Av3DNvuS2p7vzkv4u1ZuH/x00/PGTr73VO+XC++m/G9d2g4LNxP9fL35b1zYJ9wI+VT+3269vud86R9x3P+GylP6xwPncd/vr/wPeTscGJ4jvpz+nfO93ebvcIjwo+pX2+7TwVd7fei2vHHfsnb8ey/h3yhm1iId0QhHnrXydeHdVLep3lfHhF+JTwvPEDXx/tYeM/ePzwu3C/srnyb9sWgq13PrV0fsJ/uytPxqAe+SvGol32j+0ohHnqPg6yvsu/hgvCr4TjiaBz0PoqDEv/4sH+4sfKr3Y9Ru+7rvMnD8exjY+WJ7quFeMdLN051sm/Xme9efK8aHs4Ox4QfVZ39nWzf8JzwwPB1+a3dX1T7Xc75Ee9A6eyPfB1vdkF3TqFd9PbtOrPOzD6RseG88PxwgOrsfSeHhueFnwh7K7/a/Su169/Omzwczz56K0/r8G8/6OYV2kXvfp3v5uwTmR5eGV4fXsr1Vb/u/ScnhCeHZ4bHhF3Kt/a7fe2+F+fZpfYdD7/kXYpHHewH3ZWFeCdLd73q6zr5OWD9n/X9c8Obwkkh+0nWf79Ng3wP+Hg4PBwQbq38avev1H6fcH5bq33Hwx/5Ot5NBd3wQrvo7dt15jsVzyHP27fDWeFg1dnftXge/yUcEu6m/Jq+j6E7XO0SZxvpavuRwfJTyu/bqoN9oZulOtm3+xv2M7AP4eJwTjhT4zbzAs73PohPh0PDwWFp/tC0PxRd7f6L2nmL/ZK3412gOtgPujmFeEOlm6n6uk5+DvieeEo4OVyo547ndf16V+LtHg4MR6n/afv9Eh35oHd7bfuRyfLpvNGdK//2g26h6mX/rjP7SNgnMiVcFE4ID1Odve/kyHB0eHi4lfKr3SdUu8/F+W2l9h0Pf0c2xMO//aBbVIg3ulBnvgOxj298+J3wonCQ6ux9gYeFF4afCvsqv9r9hbXfp5w3eTieffRVnui+U4h3YSEeevt2nVk/4r2C+f6C8HL6H9XZfwfB+8D54aBwb+XX9PcUbde1at+LhspPKb8FqoN9obtcdbJv15l9Uex7Gh3OD78R9ledvY/qk+GI8AthT+VXu4+zdt+W8+up9h0Pf+TrePMLuhGFdtHbt9dveX9g/n+LnhueS/R+zxijfqPt/uK27zO1/cR4+XGe6G6Rf/tyvViPYT1lma7LcaqX120m6r5su9+v7fpQ7f01Wn6cJ7pl8m9ffo5ZT2Q98Lvh1zW+MX6u37+VeKwXfjn8vOYDbfeltl3vrB3XvyufzhvdFPm3H3RfV73s33VmfZ33T94LLwuXhmerzv57DN4bjw0vCvdSfk1/14Gudt2/9v35bPkp5XeZ6mBf6JaqTvbt5595IPO4O0PeT3j/Qe/54iVh6b2oaf9623lp7fvYxfLjPNHdKf/25Xox/jEuLQlZRx2oenmcHB+W1mWb/q6i7Xhcux48XH6cJ7ol8m9ffo753sh3xavC5SHrnay7cp6/T54STgpL67JNf6eIrvZ7aO168FXy6bzRjZV/+0G3XPWyf9eZfV3s27owvCNkffMQ1dn7wA4Op4Sl9dWmv1NEV7vvrHZd1/4OLsS7o6CbIt101cm+vQ7Gvk72bc4Ibw1vCKfio2vD870f9MRwbHh2eHTYdj8zutp9qM5zV7XvePg9sSEedbAfdLcW4o2V7gbV13Vy/3yg/JDPXSHfZdF73zh5Tg33Vz61+85rvyvX1n+EfJTyu0u+7cf3M/to2Lc1MpwbLg7/NWQ/Ded7P9gB4bBwXPjZsJ/yrd1fVrvfxz4OKMSzn37KE93cQrxhhXjUy77RLVZ9XSf36+wbYd/H7eHN4aiQfY6c530mE8KR4d8Az8l5oHicnZt51Fd1ncd5HsAFN0wENREzU9xQ3BUXNMUlBBIhmFwAAUXHJtBQs1wQWUTFMw1qCjUOhqBNNS7UoKIgWCmIW6WkJJZjbmRnJjUtm3Pq/XrOeV72Pffe/Of9yH3fz+fzft/7vd/1d0TnDn/9b59gp79Bh/4tf8OzW9pf7yLehJb2fK4fIN6kQrwjxLu3pX1c4ny9EO/O4MRCPK4TlzjwNwlvo+CA8IYFpwQfIE9wTEv7+7omXq/gwOA1wX7BvVUfecjrOPAGKC9xuhbiUffAQrwx0lOqb6L0Ww+8Bwp54W8a3sbBgeGNCk4Nzg0uCV4cPKul/f3dE3fP4KDg+ODU4DHBPVTvQMXlenfxqA++88JznXsov+Ohd1BFPHywHnhzC/HGi7dE/tontwPeo+HBy4L3BBfreXMf79nOweODXwteqfZBfeQhr+M0fb8vU/2uB9490ud64U2R7pKOxfLJunl/878dhuq94bk/GLy9pT2/p95n3odpwfNVD3HJ4/vh3V7gOV7d9/xB6XGdzgvfOvxenqo6uf+h4OTgaL2XO3b++7qmB/sH91J95CGv48A7VXmJs+M/6PNo6SnVN1n6rQfeQ/LL+u3zYPXX9LdL9b0ZJZ+313iC/niGvtP+3g1WPK5vLx71wHe+pt/ZuuOSpfLBuuBNlU/WjU/wzwjv4eCs4Jkt7Xm75/6ZwWHB3sp/hu7n+u4FHnlnFnhnqq5S3lmFeMMKusfiT/CR4Djp7pP7Tw1eG9xX+cfqfq73EY988B0fnuvZV/nNI67rtO53w9uvNfzg0FbFzf0f8B1JoJ4btecRh7i+r+07VuCV4lEXeR3PdRMHvr8nHybvkeFPDA4LDgpu3dr+vpX0m/mHfsFewe2Cv1R95CMe11eKRz3wnQ/e1qqzlNf6qNfxrHs76Wobf8unXvLBPv8pOo4O/6zgmcEDgtvK58eiY9P8wx7B3sE/5/qvpJd8xOP6Y+JRD3zng7et6izltR54vRXPPqDLee1Tb/ngcdufo+Ow8M8InhPs1tqe/+P80THxdg/2Da6TPuITh+s/Fo/88J0HnusiXl/xrIc6Hc96+0qX/Xo/9e0U/rnBC4Iny6/l+eO3wf0T95BgN9VDXPL4fnhcJx9xlovnOsnveK6/m+qEZ71c37/g13uMM8I/OzgqeLj8WkZ/k3j7BPekDtVDfOJwfZn0kR++87SNt1RXJ+dXPPRQp+NZ757S5fWETuFtpfec9/O84Njgga3t738yul4Iun0cGOwT/Eg+kZc6HA9eJ+UnzpPidZMe19W0XVs3efuIZ5/6SL/zwuc6ed0vfZD357jwTw9+hfYV/JT6pRWpc8v8w27Bo4N/yvU35Qv5iMf1FeJRD3zng/cp1VnKaz3wjlY8+4Au57VPR8sHt4OW8AYHxwS/Gjwt+PngDmoHTzDvSvy9g8cFdwp+Mvgb6W9RXK4/IR71wXdeeDuo3lJe66Vux7P+T0oXPPu1k3xoW0eVv8fJN7eDVvIGTwxeEvxysL/awarofTX4iVw4Nnh4sIvqIw95HQdeq/ISZ5V4J6p+1wPPOrqoTsdDP3ocz/4cLv32+Y9pzyeEPzl4WbBf8CD5/Gj0bJ1/6B88Ptg5+Bf5Qj7icf1R8agHvvPBO0h1lvJaT2fV67z4gC7ntU/Hywd/b7qE94ngkODo4CT19/T/3P9c9LwY3CF59goeoX7f4wTyUofjweui/MR5Trwh0uO6mo5j7Ae6HM9+HSEf2tarCnnhexz5l7xnR4V/YfBL9O8aR/40f2ySeEcGDw2+L7+ITxyu/1Q88sN3Hniui3iHimc91Ol41nuodPm78VHqY17JfPBS9df039z3k9Tpeehn1V+7fycPeR0H3kcaPxHnJ+LVnRfXHX9Y927S5bzwud674POW4R0SPD84gecU3EY+Px89LfmHg4IHBFuDL8mXLRWP68+LRz3wnQ/eNqqzlNf6qNfxrLtVuuDZpwPkg33uEB7rTKwjXaG6DpHPj0eH16VOUj7r6KB4XH9cvlAPfOdr6l/d9TTrP6nAsz8HSb+/s5vQXwbHBb/Gd1rf2Wfyx1aJt29wQPA9+bWJ4nD9GfHID9954Lku4g0Qz3qo0/Gsd4B02a+OfCeCVwdZVzpMfq3OH1sk3inB0vpUR8Xh+mr5RX74ztN0Xcx6qNPxrHd36XI73hT/g18Mjg8yD2EexH3PRs8fg5/Jhf00T/E8iTzkdRx4myovcZ4V74uq3/U0nceNlw/WZZ7j7VfwubO+w3xnr1Q7OF4+r4kef7dPVjtwuyEPeR0HXmflJc4a+Vy3H6nbrq17X+lyXvgnK6/nDduFt2OQdUPW+2YGLw4e29r+/lei+3/QnzysEw4NHhPcXPWSlzo+Fk91kp84r4h3uPS4rqbrpNa9ufQ4Hn4NLcSzn8fIJ7eDjeEF/yU4Nch+Cfsr3Pd0dG+WfzgsOChY2n/ZWPG4/rR8ph74ztd038f6qNfxrHsP6YJnnwbJB7eDHuGxHsV6003B6xinBHdRO1gf/V7HGhUcHtwm+Jb87KG4XF8vHvXBd154u6jeUl7r2kb1Nl2vs2+jCjz7Olx+uR1sHx7zUeaR04Ps67BfxH2/jl7PXz8fLO0nba94XP+1eNQD3/ma7mPVnXdb9/7S5XjwuX5owefNw2N/gv2HGUHOG+wnn3+eOr2fcWqwdH5hc8Xj+s/Fox74zgev7rmJuvsw1r2jdDleG3+j9vE87t4svK8HLw9yzoDzC/B/lj9OSLwTg6VzDZspDtd/1vnv86jjhAKv7nkK6+ineuFZN9fJ7+9zz/D2DjJfYp5zrfqPtv4p978WPe8GPc86Tf2D+x3yUofjweup/MR5Tbx9pMd1NZ0f1u0/7dNh0u+88LlOXn83ttA4ifHNrCDrf6wXct8vosfjqmHB0nriForH9V/IP+qB73xN1zHrjget+0jpcjz4wxTPPncNj/0c9mGuD/5z8HPyeW10e//nC8GDg9uqPvKQ13HgdVVe4qzV86i7H2Ud26pOeNZ9sHQ5L/wvKK993pV+Nci+7zXBacFT5POG6PV+8+DgkGAP1Uce8joOvF2VlzgbxKu7/20dPVSn46EfPY5nf4ZIv33eWc+Z53hRcDjPVT6/ET1+L44K7gxR9e2seFx/Q/5RD3zng3ew6izlrfs+D5d+63E88w4u+Nw9PMb5jLtvCbLvNUQ+vxzdnheMCZb20chDXseB1115ifOynkfdeUrdfT7r3ku6nBf+GOW1z73UnmgH3wyyr3uCfH49et3+zg6W9ol7KR7XX5d/1APf+eDV3Z+u+92w7v7S5Xjwz1Y8jwf7hsd5P87z3Rq8Ocj6LuvB3P9h9Puc4Njg6GBp3biv4nL9Q/lOffCdt+l6dd1zjvZjbIFnn06Rfnj2dbT88vyGcxCcX7gtyPkRzpvA93mJccHSOZR+isP1zuLVPZdR9/yLdRyrep0X/jjl/djvXcMbGBwRvCo4JThS342u+aN7cJfg54IDg59WfeQhr+PAG6C8xOkq3gjV73rgXSV9rhfeSOku6bA/AxXP7yXzeObpNwRnB/kdBXzP90cERwb9u42q32M0XVdwXT2V3/HQM6IQz3pHStfHfn8aHvN55ut3Bv89yD5tWz+YPzz/nxg8L3iS6qv6nUXT/eO66xHWNbHAs96TpAee/TlP+v1esm7K+cW5wUVB1kvh+xzk+OCFwVGqp+45yrrrt65zfCGe6x+lOuFZ74XS5feScy7sA7DO/93gXUHOwXCff0/CvsDk4EVBn6up+l0KvKrzN033Mazjs6rT8dA/uRDP/lwk/R5nsV/L/u2c4Lzgt/Ue8F5wv/d5zwqeE5yg5+z3p2rfGF7V+V94c6THdTV9v+fJF+uDZ5/GS7/jwZ+geG4Hp+v94Ln+MMh8nPk79/n8GO/BVcHS/L7qHDy8uufV6q4r1G0H1j1YuhwP/lWKZ585H8I4mXHwf/J9D54jn32ehHHzxUH/XoP6qn7XBa/q/Aq8qt+JwLOeA1Vv03mDfbpYPPvMPjrnajln+/3g/cGZ8tm/S+Ic7qXBK4JDVV/V75vg1d3frzoXbB66Li3wrHeo9MCzP1dIv8cbrHuwrrFU9VAffK+PzFB81133HHXddZi6flnPjEI8671UutwPsr9Hu+B9Xh5cHGR8zXic+/37LdrBdcErg6Vxe93fg1XtQzZt53XnFdY/QrqcF9+uK+S1r1fKLz8f1kNZ3/9WcGHw9uCNjHv0fLxvcG5wUvD84D8Fj1K9VeuxTfcrLlK9pbzWe24h3o3ywXrg2bdJ8gPe7QXe+YXnw7k0zvEyf2J+tDL4EM9bz8fnqz3vmh2cHvS5uKrz2vCqzs/BqzqX3HS+aN0nS4/j4dfsQjz7OV0+ud8dp/zc90CQfWD2hbnP5xDJc03Q+8bUV3VOGV7dc49V+9VNfbbu06TL8eBfo3j2mfM6nMd5NLgiyDrrBfLZ53uuD94QLK3vVv3eHV7d80R115Wt7/pCPOseK13w7NMN8sE+c+6J/Xf2159UXdPls3+XxH78LcpnHVW/b4JXdR4LXt3zA3V9tv5bCvHsz/XSb585R0I7oR2sCrLeMFU++9wJ7eamYGn9oupcJ7y651zqrpvU/R5Y92Tpcjz4Nyme+0/OL7DvwL7C94I/0jiAcQH3+3e67EdcEpyift7jh6rf/cKrOmfRdB+l7vjGflxSiGefzpV+ePZ1ivzy82Ef4l+D84N3B+8IfoN4ej7sV5wevCD4leCXgmcEB6reqn0QeNQH33nhTVG9pbzzpdv1w/uGfLAeeHfLP/sA7w75a5/8neKcFfNo5slP6bvId5L7fD6fefWt+i76O1p1zh9e1fmvpusAdb/z1n9rIZ79uUX67TP7/Ozjv6B2STu9TD77XMB8tTfvn1Jf1e/k4dU9h1C1b+t46JtfiFf3u2SfLpEP+OR9PObHDwbZ12vbl82NzJ+nBb1/WLUv2HSe73pGKr/jwZ+meNbNueHVQfbZLpduzhHfHCzt51WdQy7lvbnAq7uP6Ponql73L6xns179cnCt3kPeS87TcL/Xwe8K3qH3zOduqLfqXF/T9feq8z5N25l9uauQ137Nlw/w7O8d8q1LeHz/OCfGPif7mMuCLwZfCrL+yHolcfw7GPZBZwUXBO8MltY3q35fA6/qfBu8uvu4dddf7c+sQjz7NUP64dnnBfINnp/DnfLV/Rn7F8xPmX+uD7JOybom9/l8FPPVu4Oldc+qc1Z191Wazq/rrsta93XS5bzw71Ze+8y+54LgfcElwf8Ofls+sy/65eDlwanBq4NN91nhUQ9854Pn+iYoP7z7pNN1w1siH6zLPPJfLZ59Zt7DvOaR4MPBHwQXymfPk64Nzgx+NThJ9dVdT647L1uoOkt5fyBdrtN58eHaQl77NFM+2Oe5eh94Pk/ou7dIPvtcAM9zjr5n/k7WPV9Qdc6m6ftc9ztu/XMK8ezPLOm3z6yHM45iXNWxY3jBlfLZ57EYd60OPhWcrfqqznU1XaevGgfCs47ZqtPx0L+6EM/+PCX9Hn9yXoJ1LdateuT+XYKMmxiPcb/PGbHetT74VrA0bqs6twSv6lxH03W6uuNK+7G+EM8+3SX98OzrW/LL7YD2RX/weHBN8Gm1P+5zf/FvwW8Gb1P7q9vvNG33j6t+1wNvjfS5XnjWO0d6HA/+bYpnn/n+0x88G/xl8JngY/LZ/cW84HeCc4M3Nux34D2svMSZWYhH3fMK8R6TnlJ91j1XuuDZp+/IB39vWAdhnsY87A3Vjx76ce73+gnzt/uUt9TfV63/1l23+UfHGVXPxz7Mk76m8137e594bges2zAPYJzfLd+rrkHWdbjP5ziYF6wLrg02XSeCV3VuBJ7rm6b8Tec71r+uwLM/a6Xf6wqcT2L+y7y1NffvFvwM/Xius75LHJ9vYt67KvhO8HfB0npw1TkzeFXnq5quQ9ddB7APt0qX4+HjqkI8+/yOfIPn5/A7+er2w/iW/on+51fBt4Ivqv14PEx/tSi4OLhA9VWNq5uuo9TtX61rUYFnvQukB579WSz99pn+/fnga8Hfqq6n5TP9/38E/yt4j/I1HU/Aox74ztfUv9ek03XDs+5F0mUeca3f/TX72ZyHaZtvpT3sGmRcy3i5bX07cX1OiXnJhmBpXF11Dgde1b47vKrzU03nZXXnB/ZrQyGe/Vwvn9wOGJ8x/no9+GbwleBzagcez90bvD/43eC3VN8zisf1ueLVHT8+pzpLea3v3kK8V6TfeuDZp/vlg/trzs2wX0o/RL/w6SDjAMYNrJcSx+du3I+9rXGD11epv+rcFLyqcz9113XhVe0bN+2v646v7O86+eW88N9WXrcfxtmMj98Lvqv3jfeP+zwuXxZ8RO9R0/lS03lA3XZhPfeqXufFh2WFvPbpEflgn9eF95vgO8E/BH8ffFU+L8wf3wsuCT4cfCD4fdVHHvI6Drx1ykucheK9o/pdD7xXpadU3x/kg3XB+718sm77TP9PP/928P3g/2mcxX0eL/wwuDy4NOhxW91xR9X4Dt7bqt/1wLOOxarT8dC/vBDP/iyVfvtMO+L9/zD4QXCD+hfuc7tbGVwR/JH64br9VdN2/qbqLOXdIF2u03nxYWUhr31aIR/s84t6zjyfrfJ9Zx73knz2PIPn+UKwNC+s2kduOq+pOx+t+z5b/wsFnv1ZJf32mXbyv8GW3Ncp2Dn4vnymHT0UfCL4ZHCN2hH1kYe8jtO0/VIvcV0PPOtYrjrhoZu41mUecdeI9/9wSEIJeJydm2eUVdUdxRGc0RlkXmw0iUuxIoooAhaULghIVSEaEWwRAaMGkN57R0zggyGiLgt1GHrvimsJMcYlNhCVJC5jiiYxCij5wN6z1v3JyT33+WVfuPvs/97/e095j2dRhRP/nSb8oOIJPCSsXekEXi08W/hf3f+iYnL8i4UncJHwS+F3wgPC7cJVwlMrJOvaB/XM+wD1rfMiePZvXfoyzzrOFfLH/NuRyzz26wD6QH/mfwd/p4unP1Y4orpHhVU0rkR4mvBYxeS4XbrYLdwvfE/4B+Fr8Oc6rksd83zfda2zK6Bn3/sDetZxnpC/05Cfecxjn95DH9jn71T/B2GRxp0lLBYeR5936mKP8I/Cj4TvCN+AP9dxXeqY5/uua52d4NmvdenHPOs4T8ifc1uXucwrRp+Yu0g8rxffYN55vtQQVhf6+R3FerMN64nn2WfCT/Gc+Z65rn1Qz7xvMO+ssw282PUhdh4w/37kYl337bNAXfb1U/SL8+Df8vmtsEDjqgrPFOYqJcdt0cUO4e+Fh4QfCt+HP9dxXeqY5/uua50t4NmvdemHPOc6FOAx7/vIYx778yHycx6cKt4ZwguEFwprwp/9evw+6b4r/EL4V+Fh1GeuU6Hr+/vAsz/zWTdrPy9Abvo3j/kPIZd57Ndh9IE812e/OA88/zxvLhNeLjwP+4vHcb5+Jfxa+Cfsw7H7Vdb1oQQ+Q3WZ76uA3nnIzzzmsU9fow/s85l4zn6O9YWNhNegz5xffu5HTNBEOZpxnpp3TYBHvdj3lLmOBHjM7RxHwGNfjiI3+3yueD8V1hVeJ7xSeD76/LEu/iL8j/AH4TfCz+HPdVyXOuadi7rW+Ri8uvBPP+adjzwhf9ehD8xl3pXoE3N7PS4Q+jl7vaknbIDnbz7Xq2+F3+N9zrrexb5v9eCXPsxrgDz0SR7rmsd9sCL2V883v9ethNcKL8U++CbOFZynJSIe05//Cb+uax/UM68i6lvnTfBizwux6wtzu+6xgJ77VRJY/9jPY+gT32fvDz5HNhbegH3DfJ4vT5FgJeFX8JN2Ps26T9Gn61OP/q1nn+Yxr++fElhnfS735/vrhR3gyz49jt8XVJR+VdRjjtjPAbHfT8T2j/nsl3rMfQpymcc++b51uW5chufSXNhMeKOwDs4jHs/nXVlYbF/Cf+H8FnvOyfqeXQ6/obp1kI8+Wdd9qYx5aN6N6Bvzm8f+FqNvnAde/70fNBW2ELbEOcfjfrRfSP8MYRU/QPhL23eynq+awj/9mMccFeDTvBboA3ORZ90q4LHPDcVrImwjbC9sK7wZfT6ui0Lpnik8V3iW9wP4cx3XpY55DVHXOsfR5zbwTz/m3Yw8IX/t0QfmMq8t+sTc7PM1eM5+Pp2EnbH/ehzP5X6eNYQ1hSXwl3a+z7rvx76nzFUjwGPeEuQxj/2pifw8b3h98Xpzu7CjsDXOG1yHqgmrC3MZ1zHzmqGedYoDevZZLaDXGjlC/pi3OnJxH/S+6n2zh/Bn8GWf3hc8nvtxbeFFqBvaP9LOR1nPAbH7Vmzf2ZfagbrsVzX0wTz29yL0je9zJfHGCMcKL/Y6gfd5r+Ztewl1EP5df/8W5nUl6Pj+3gDPPqxPXiH8heoyh3kd0C/m9n3X5zrr/a+dsIuwO9Ylr1Me5/3xHOF5wgux3oT25dB+a579mM96WdfPLshJ3+Yxdw3kop75F0KP7+VPXNfvsXCScDLeyw/U6IPCvwm7SLgr/FjXdTjevMkBHvUugl/6IM857I885nQ987nOel3wvL9P2Et4t3Wwfns815M6wiuEFwtrYf+K3ReyrmMd4TdUtyvy0Sfrui91AnXvRt+Y3zz29wr0jeuG54ff/97CB4UP4BzicZxPdYX1hFflea7JOn/prybqU8/56gb0mL8e8pnH/lyF/Oyz15m7hD2F98NXd/TZ69AFwsuFV8IXc7iO61Indv0zryf800/WPt+PPjAXedQzr1g897sa9lfvn78Wjhf6exN/H+Pfl1jnEz0A7s/3CTsK+f0Nfy9TDfq+/wl49ms+65uX9juYrOeM2O+j2LeK6APrut/uF+vyeXREf7mP+HtXf27yfPf8GyicIhyHfYTf13KdaCrsJrwdftO+/zVvXIBHvdjPgbHrG/vQNMBjn7ohv3ns4+3oD5+Pzw+XCC9FH6zzG5wzPN7njH/g3xvYv144b9iv69oH9bKecy5FHvrK+u8Mse8F+9Qr8D6yj13QHz4fz1vPt2nCp4SPCv05rQOeD+f7ncLmwuuEoc+Jad9TZ11nYj+fMldt+DWPfbgO+cxj35qjH8xh/p3I4b76c0IP1O/n9VPoc6L5zNEI57ysn7+z9iv23MocdeCXdc1vhLo8T90H/mPC/sKHPH9wnmL964WNhVcLr4C/tHN11ry94DNU9yHkok/WdR+uD9RlnxqjD+yzz10+h/UR9hX+Uvgg+sxzWgNhQ+ENOC/HnveyntP7wD/9mMcc9eDTvL7oA3ORZ90bwOP6/ADqe9wg4WjhROzzHs/PH67XTNhO2Dmw36d9nsl6zojtJ3M2C/CYuynymMd+tUMfzGM/O6NPXJ/9PAcIB8O3c5jv53yLsAV8hN6r0PtinuubzzpZ+zoYueiXPOq1CPTL64vXm6HCIcLH0S+uQ62ELYU3ZlzHzOuPetZpHNCzz1YBvceRI+SPeVsiF+e/9z+fK6YLJ8CXfXq993ieV+4SdkLd0L6Qtv9mPSdl3Y/S+s6+3BWoy361Qh/MY387oW/cB/3eex6MEk4VzsC643GcJ7cJ7xB2x7oTO9+yrnej4J9+zJuKfPRrHvO2Qx7qmd8depwHQ/D8/HzmCp8RzhQOwzzgPPNzvVfYU9hD2DrjvDVvCOpbpyV4se/jMOQK+WM/7g3ozUS/mNs89rUn+sV5MBrPc57wOeEC7Ksex/ejt/BR4SOB/Txtn876PtJfZ9SnnvP1Dugx/6PIZx778wjys8+eN08LnxX+Fr5moM+eVz8XPiz8BXxlnafm2Y/5rJe1f88iJ32bx9y9kYs86zI/+zwQ74Ofz2vC14VT0GeeP/08ZwvnCLvBX+w5NvZ7utj3mTm6wSf1nH92QI/9mYP8Xo99vvO65X33d8LnsZ6Zz/24j7Af1qfY/Tzr+kmffQJ69H8vfJrHvP2Qi++lzzv+/mijcBN82afH8fuoCcKJqMccsd9rxZ7D6HtCQC+2z8zdB7nMY58mog/s81w8lxeELwrnY3/0OD7n/sLHhPfjvBG732Z9r56Bz1Dd+chFn6zrPvQP1GWfHkMf2Gev216fXxUuEi7GPlr+/RPW718JBwgHYh/Nul/E7t+vwj/9mMccj8KneYvQB+Yiz7oDwWOfF4r3knC5cI2wVPgy+txXeo8LhwhHC4cKn4A/13Fd6pi3EHWt0xe85fBPP+a9jDwhf2vQB+YyrxR9Ym72eQGes5/PSuFu7KMex3Ofn+cI4Szso7Hnx6z7d+x7ylwjAjzmnoVc5rEvs5GbffY6s0S4VrhKuBTrkMd5HRokHCMcKXwK63XsukaefQ0K8F6Ez1Bd5hsD/+YtRX7mMY99Gok+sM/eV71vbkY+530efeY+PAm+Q/tH2nko676fdd9Ke27MPwj56M/8SfDHPns9LxOuFq7DPFuMPnu9Hy4cJRyLeRbaZ0L7h3n2Yz7rZV0PViMnfZvH3COQi3rmj4WeoPzzg38/u164Qejfnfh3Kub7d7XjhOOFod+vpP0+lzz7GBfgxf5uhjnug1/zmHs88rFf46HrcT5PT0O/+Hsd64fO+Wn/Hm5e2u+Csn6+iO0X804Az/OQ67Xn/Ras3+Xfz2LdmIx1OOv6H7su0c8Y1Kee+ZOhx9yroOtxW5Gb+411p2Tcp1jXdawzMs/c9D0FPOb2+rNTuAvrUfn37Bo/Qzgzz/XMPNczn/rm0c9Y1Kee+TOhx9wroetxu5Gb67Z1Z6F+7Hofe56MzU3fs8DjeujfYfn7Mn/PtUfo31+Zz9/H+fuwp4W94Cft93Xmxf4eLPb7PfrvBZ/UM/9p6LFfk6DrcW94XUG/+Hs1688V8v9jSPv/DsxL+12cefTVFfWz9ot554LHfnXVxRDhFuFW4dSCJL+W/qGspXB37gRO0Z/vKEr6ob7H1QLPdcyvFdCjT9dvCR79W2cKeMw7Bbm4DvUTbzN82Jd5jaSzK/f/fXqcdRsVnZzHutZtlGd/6N886/I9uUkXE4Sb4Kcf3pMC1esk3Al9+vZ41/F48ujD+gV59ot57LMTeMxrvZ2BfnXQxWjhjFxSZwL6VVX12gl3QJ9+qO9xVQP5zK+K52Iefbp+uzz7xbw7oct5NVy86bnkePsy71bV2Z7i0+Ose2vRyXmsa91b8+wP/e+ALt+T1roYJJyWS+oMx3uSU71mwm0pvqnvcblAH8z3ferRp+s3y7OvzLsduuxXK10M8PqeS+oMQr9KVO8W4dYU39T3uJJAH8wvwXMxjz5d/5Y8+8q826DLfnXSxUPe33JJnQHoVw3Vu1q4JcU39T2uRqAP5tfAczGPPl3/6jz7yrxboct16B7pTva5Jpf0Zd4lqrM5xafHWfeSopPzWNe6l+TZH/rfAl2+J3foYoxwUi6pcw/ek/NVr71wU4pvj3cdjyePPqx/fp79Yh77bA8e824Gn/1qZl3hxFxSZwz6Vax6XYQbU/x4vOsUF52cRx/WL863D8hjn13AY95N4HNe9fW5J4fxmFcNVWdDSn2Ps27DopPzWNe6DfPMTf8boRvKPVE4PpfUYe7OwvXQDemZzzyxuenLdTuDR98bwOf8aG5d4bhcUmci5kdl1esoXJfih/oeVzmQz/zK6HN5Pvh0/Y559ot510OX78nD0h2bw3jMj/qqszbFp8dZt37RyXmsa936efaH/tdBl+9JR6/jXvdzSZ2H8Z5UV72uwjUpvj3edTyePPqwfvU8+8U89tkVPOZdCz771UQXT/jzn/cb71/oV6Hq3SRcneKH+h5XGMhnfiGei3n06fo35dkv5l0DXc4r1x8hHJVL6pR/r6A6bYSroBvSa4P+Zs1NX67bBjz6Xg0+35MGumgrHJlL6ozAe/K9/oH4LNVdmeKH+h5nHeYz3/epR5+uf1ae/WLeVdBlv67VxTA/31xSpy36dUw5WqtuWYpvj3edY6efnEcf1j+Gvsb2i3nsszX7irwrwee86izd4X6fcsl65tVUnRUp9T3Ouh5HHutat2aeuem/DLp8T27TRX8/p1xSpzPek7NVr7GwNMW3x7uOx5NHH9Y/O89+MY99NmZfkXcF+OxXQ108KRzq9ySXrGv+cb3nTVR3eYofj3cdjyePPqx/HPMqtg/MY59NwGPeUvDZr3a66CEckkvqPIl+naN6tYXLUvxQ3+POCeQz3/epR5+uXzvPfjHvcuiyX7P19+/qL44Itwnn5JL8yar3nHCXcKrwNez31reO708uOjnPPqxPHn1Zbyp4zDEVfs1j7l3Ix37NUr19+osfCpI6s9GvSdKZL9wDfeaz/mz0aVKAZx/zA7zYvjLPHvg2j3mfQy7uczNV//2CZJ1ZeE8mavwLqMs81vN4358Y4LnuCwFebB/pfz788j3ZqIvXhQcLkjoz8Z5MkM4c4SvQp++N0PH9CQGefcwJ8GL7xTyvwLd5zPsCcrFfG3SxV1ipMFnPOcwfL515wr3wwXwboOP74wM8+5gX4MX2lTnmwK95zL0X+div9bo4KqzicQXJHOaPk85u4X7oM9966Pj+uADPPnYHeLF9ZY558Gsec+9HPvZrnS52eD8uTOqsR7/GSme68CD0mW8ddHx/bIBnH9MDvNi+Ms9B+DaPeXcjF9ftteJ9Dr/2X/79i8aXoS7zrMV43x8T4LluWYAX20f6nw6/zL1GvM/gYy1yj9b4pdCjzzUY7/ujAzzXXRrgxfaH/svgl/NjtS7eEH4LP/Zn/ijpzBXugD59r4aO748K8OxjboAX2y/m2QHf5jHvUuRiv1bpYr/w9MJkvdXo10jpLBS+DR/Mtwo6vj8ywLOPhQFebF+ZYy78msfcbyMf+7VSF58Kz/C6XZDMYf4I6SwRvgt95lsJHd8fEeDZx5IAL7avzLEQfs1j7neRj+tQmfh/hl/7L//+ReNLocc8ZRjv+8MDPNctDfBi+0j/S+CX78kKXWx3zsKkThnek2HSmSbcB336XgEd3x8W4NnHtAAvtl/Msw++zWPeUuRiv0p18Y6wsDBZbwX6NVQ6C4RvwQfzlULH94cGePaxIMCL7StzTINf85j7LeTjvFou/kfwa//l36No/EvQY57lGO/7QwI8130pwIvtI/0vgF++J8t0cUhYszCpsxzvyWDpLBIehj59L4OO7w8O8OxjUYAX2y/meAl+zWPuw8jHfi3VxZfCswuTOsvQr6eks0Z4APrMtxQ6vv9UgGcfawK82L4yxyL4NY+5DyDfj/4/KvE/gV/7N2+Qxi+GHvMswXjfHxTgue7iAM86/wOVwWp0eJydnXmwleV9x93uhavYK1i1HScuERAmjopbhYCMVgFTzUzGAi6AUVQiO7jgVtMkjY4TUQL3qsgqsms0CtbUREVto0anqRIdY1xiUqeKcU1rmrh1pn4/Z+Z8vE/O68s/v5f7fJ7v7/v9nfecezgPF37Xtt3///rnjk/rvNSdPi3bvZL134m7LbVXuCxvd1su/jN17/ZmndvbmvmLonNH6qvSv1h+bpMO6xcVOHzcUeDQwV+pr3PcJr9wzv2q8uXLDX5j+CfkF/9wF2Z/t/ScZ6P2s35hgaNvd4GrOkf7v0N+fZ9syMXW1L9ub9bZqPvkgugsS/2t9O17g3RYv6DA4WNZgas6L+foll845/6t8nle63PxZuof5XuD5jU3OvemPiJ951svHdbnFjh83Fvgqs7VOZbJL5xzP6J85N4xdZ184pv1Odpv/+u0j/U5Bc7zMNdqbn5dODXcOalrUy/tbOa+mP0Hp87m9UGc9eC/2NEzRx90zNnXbPmAs2/0ZhdyX5L1/86+91KZM9wPwj0QnZ8U5o4e+1n/QWfPHH0fKHD2M0f94eyf9QcK9+tF+cIazZX1kdk3S48z/bwfbmTh8YAfWdCzj9nq3zscj9+QcKenrpYf+p3d1rzvgwj15/t+Z8/+D5I/92M/enD0g2fdevaNj/6FOaN7UGHOVR8Pz2mW5pDfNr4fzMvX/yP8u6l7ZqC7pXL/cV+z//b8/uYI/zj116nP6z71/U9/dFm/vcDhk37mqj7vnBffN2uensevlRPOc3pA+eE81+c1Lz+PL1Zu5sD6TPn2PNg/T3Od2dEz5/maa/U4+PWX58FZqbfqeQHH8+JLqTN035b04P28qvr8s68Z8gFn3+jBO/dFWf+f8G+nXqw8G/P7B6PzL4W5o3exHr+NnT1z9H2wwNnPTPWHs3/WHyzcr2fy/ji6zI31wdk3XY8z/bwfbnDh8YAfXNCzjxnq7/fFp+ViCu9bO5t16Ad/QHSGpE6Tvn2znz4HFDj7QP+AmvNynmnyDee805XL8xqWi5m8r+1s1pmiee0UnaNTp0rffthPn50KnH2gv1PNOTjPVPmGc95pyuV5HZeLb6auUJ+Zmlef6JyYer707Yf99OlT4OwD/T415+A858s3nPNOVS6/jk4Iv1z69IMbmP3fkJ77sw/dgQXOfdEdWDO3/Z8vv37/e0S4canL5Ad/R+n978cR2i+6U9QH/9vJHzr0RcecfdHnY71Ptr/tCvNzPvzuV/Px8Jy+oTn4/qL/7NSl8gOHn2Gp50m3pDeskKdqbvs6Tz7g7HuKfPp16Bjuw9Ql6kNf+N7ROTx1Veef92N99vUu5IPvXdCzT/ofXnNeznuecnlef5OLy3jfKz/na17bR+/41Fs6/7xv9tNn+46eOftAf/ua83IefB4vznnRg/fzalK4xdKnH9yg9FkpPfdnH7qDOnrm3BfdQTVz2z/cyha5Z6XeJD/OPTR1hXRLevDOUzW3fdF3qDj7Rm9F4fkxIhdX8nzobNahL3yv9BuTulz69sN++vTq6JmzD/R71ZyD8+BzjJ9vyrtCvOf1t7k4he9Tnc06V2peu6bfF1KXtfBjffbtWsgHv6seFzj7pP8Xas7LeZdL1/MamYvxfH/rbNY5RfPqSL/9U5e28M1++nR09MzZB/odNeflPPjcX5zzLhPv1yF0p/L9jT+P6fWFPkekLpFuSe8Izffz5rEv+h4hzr6Xivd9MioX3049l/cp/HlD98lu6XdS6s0t/LCfPrt19MzZB/q71ZyD8+DzJHHOu0S85zU6FxekntPZrPNtzatv+o1IXdzCj/XZ17eQD76vHpfG5xPySf8RNeflvDdL1/P6u1xMTJ3c2axzgea1R/odmHpTC9/WZ98ehTnA76HHBc4+6X9gzbk672Lp+nWI/vNSz+5s1oHDz7GpN0q3pHes5vt5c9sXfY8VZ983ifd9cnQuvpZ6VmezzjzdJzuk396pN7TwY3327VDIB7+D5gxnn/Tfu+a8nPdG6XpeQ3PxndSvdzbrfE3z2jH9Tk7tbuGb/fTZsaNnzj7Q37HmvJwHnyeLc94bxHteJ/P+IvXMzmad72hee6XfYaldLfxYn317FfLB76XHpfF+Tz7pf1jNeTlvt3T9OkT/S1IndTbrwOHnuNRF0i3pHaf5ft7c9kXf48TZd5d43ydjc3FN6vfU5xLdJ/um3ympYzUH+2E/ffbt6JmzD/T3rTkH5xkr33DOix6857UqF9v4Qm4kzsE4X2N5Q36/OXo/Sy2du62SDusbChw+0DdX9bzPefC5WfNy3geVy/O6JRfP8z6kvbnfKt1f6+NrdfRelg/nu0U6rK8vcPhA31zVuToPPldrXs67Wbk8r5W5eDJ1Z/4eQFtzDvh1fD+I3i/kw/lWSof1dQUOH+ibqzpX58HnDZqX865WLr9uz0mfV+UX/3Brw92pvs6DHvtZX1vg6IuuuapztH84dH3+Mzv7P+F+yEI//h5wW7NP9q3J7x+P7s9TX1A/56DfHM1jTYHDF33MVZ2f89wpv3CeA7keF+c5vaA5+P6aFT+PtDX3mS2fq/P7+err3OjN1vxWFzj6omuu6rztHw5dvw7NzP7X84W+7c06+IO/Nb/fFL1fSd++0Z+l/LcWOHygb67qvJxjvvzCOTfrmwrzmpE+b/E+t71ZZ6bmdW50fpT6ivSdD/2ZmtO5HT1z+EDfXNW5Oscm+YVz7leUz/Oanj5v5AsftjXrzNC8zonOPak/lb7zoT9DczqnwOHjngJXda7O81P5hnPeHymXX4empf+/tjX3ma7Ha3L2X6e+zoMe+1mfXODoe12BqzpH+79Hfn2fTI3uY/nCX7Q360zTfXJ2dBamPid9+0YfHdbPLnD4WFjgqs7LOa6TXzjnfk75PK8bc/Fy6kdtzTpTNa+zeH+b+qj0ne9G6bB+VoHDx4YCV3WuzrFQfuGc+1Hl8/PqBp6n8ov/xucv2b9Aes5zg/az/vUCR98FBa7qHO1/g/z6PunOxVOpHe3NOviDPzM6S1K3St++u6XD+pkFDh9LClzVeTnHAvmFc+6tyud5deXiv1J3aW/W6da8JkXnrtRnpO98XdJhfVKBw8ddBa7qXJ1jifzCOfczyufn1aLw78sv/hufw2f/Fuk5zyLtZ31igaPvlgJXdY72f5f8+j5ZmIunU/8gP4t0n0yIztLUh6Rv3wulw/qEAoePpQWu6ryc5yH5hnPeLcrleX0/Fz9P7Wxv7rdQ8zojOotTfykfzvd96bB+RoHDx+ICV3WuzvNL+YZz3qXK5XktyMWLqTvw59225hzwp0dnXeqT8uF8C6TD+ukFDh/rClzVuTrHYvmFc+4nlc+vQ9eHf05+8Q93Wvavkp7zXK/9rJ9W4Oi7qsBVnaP9r5Nf3yfX5eJnqdvz/rGt2R/8qdHpSn1C+vZ9nXRYP7XA4aOrwFWdl/M8Id9wzrtKuTyv+bn4Vepf8Tl4W3MO+PHRWZP6G/lwvvnSYX18gcPHmgJXda7O0SW/cM79G+Xz8+ra8P8mv/iHG5f910vPea7VftbHFTj6Xl/gqs7R/tfIr++TifnzyjP5Qq/2Zp1rdZ8sDL8iek9J377RR4f1hZ09c/hYUeCqzss5rpdfOOdmnf7k9s/F83PJv29rXvfPM9+vflV//vn3Ba6kB3+/9Pw5Ozw/t8nPZR6Q2r+9WY99/vlrfo7zzdS3avqDa/Xz3nD2d7/6w1X9+VTnf7PAeT5vKb+fV/AnpU5MnSQdeHT23PnTemDqoJ17ztfKjzl8oG/OvtCjP5zz4HNPcc47SLk+8/em8oWZqbO0H479R6cO1Zyq9i/1PbrA2c8g9W98Di3/Q+X3M+cS4S5KvSL1H6QDj87I1FGpo2v6MYePkQXOvoaqP5zzjJJvOOcdrVy+T+AXpi7Sfjj2T0idWPDZqn+p74QCZz+j1b/x5y75nyi/zg2/MvUW7Ydj/9TUaTX7l/pOLXD2M1H94ex/mvx+5u8PhFufemfqD6UDj87c1EtTL6vpxxw+5hY4+5qm/nDOc6l8wznvZcrl+wT+x6k/0X449n839aqCz1b9S32/W+Ds5zL1h7P/q+TX72vgH0x9JPVx/rwgPfahd03q/NRFqV01/ZnD1zUFzv6uUn8455sv/3DOv0j54DyfLuX3/QX/i9RntL/xOpj9y1NXFPK06l/qu7zA2U+X+sPZ/wr59f0F/0Lqy6mvpb4uPfahtzZ1Q+rdqZtq+jOHr7UFzv5WqD+c822Qfzjnv1v54DyfTcrv+wv+/dQ/aD8c+7ekPlTI06p/qe+WAmc/m9S/8Tm7/D8kv76/4D9O/SS1V74h9u7VrMc+9B5LfTz1qdSna/ozh6/HCpz9PaT+cM73uPzDOf9Tytf4c77m87Ty+/6C75e6u/bDsf+F1BcLeVr1L/V9ocDZz9PqD2f/L8qv30fB75G6T+q+0oFH5+XU11Jfr+nHHD5eLnD29aL6wznPa/IN57yvK5fvE/iBqQdqf+N1I/vfSX234LNV/1Lfdwqc/byu/nD2/678Ojf8kNTDtB+O/R+kflizf6nvBwXOft5Vfzj7/1B+nRt+eOoI7Ydr7N/l09prl3r9S33RNWc/6NEfzv5ZR9e54UenjtF+OPb3Te2n/FX7l/r2LXD200v94ey/n/w6N/zpqWdoPxz7+6cOqNm/1Ld/gbOffuoPZ/8D5Ne54c9JPVf7G5+zZv/BqYfU7F/qe3CBs58B6g9n/4fIr7//wU9LnZM6Vzrw6ByZ+uXU4TX9mMPHkQXOvg5Rfzjn+bJ8wznvcOXyfQJ/Werl2g/H/uNTTyj4bNW/1Pf4Amc/w9Ufzv5PkF/fJ/D/mPq91GulA4/OV1LHpo6r6cccPr5S4OzrBPWHc56x8g3nvOOUq3QexnnMm4XzMM5p7tW5Q9V//7nqeZh93CvOjzc85x4DUv8oHXifN72d6n9Pu6qfxuttezNfOtdq9e94wznHI/LrvvBvq6/nBc85yJmph0oH3udIg1P/VNMPXNXzKvtC70/Scw7WB0vPuVmnr+cFz3nJ7NQp0oH3udKw1CGaX1U/cFXPr+xrsPrDOccQ+XVf+GHq6+878JyfXKn9cD53GlOzP1zVcy37Gab+1oMfIz3fJ/Ccn3Sl/pN04H2uNCn1qzX9ND631fxL51f2NUb94Zzjq/LrvvCT1NfzguecZVXqYuk0/p5LdDiPmZ46uaYfuKrnXvY1Sf3hnGOy/Lov/HT19fMKnnOXu7S/8X4y+zmXubxmf7iq52H2M139rQd/ufT8uSo85yr3p96berf02OdzqatTv5V6RU1/cFXPwezvcvWHc54r5BfO+b+lfPYHf7X8+f6C59zlCe2H87lWd83+cFXPzeznavW3Hny39Pw6BM+5yrOp/y4deJ9HrUy9qaYfuKrnXvbVrf5wznGT/Lov/Er19X0Cz/nJNu2H8/nU5pr94aqef9nPSvW3Hvxm6fk+ged85H9T35AOvM+VHk69p6YfuKrnV/a1Wf3hnOMe+XVf+IfV1/OC5xykI/Uj6cD7vGlr6qM1/cBVPdeyr4fVH845HpVf94Xfqr6eFzznJX+Z2kc68D5Xein12Zp+4KqeX9nXVvWHc45n5dd94V9SX88LnvOT/VL3lg68z5+2pb5a0w9c1XMu+3pJ/eGc41X5dV/4berr1214zl0GaX/jdSj7OZd5r2Z/uKrnXPazTf2tB/+e9HyfwHPucnjqQdKB93nUR6nv1/QDV/Xcy77eU38453hfft0X/iP19bzgOa85hs+5pQPvc6zeqZ/U9ANX9bzMvtD7RHrOwXpv6Tk3670KnzfDc85zYupx0oH3+dfuqX00v6p+4Kqes9lXb/WHc44+8uu+8Lurr+cFz/nQhNS/l07j7z3o3Gpg6j41/cBVPZ+zr93VH8459pFf94UfqL5+3YbnHOk87W98XqxzrUNr9oereo5nPwPV33rwh0rP9wk850MXpE6RDrzP10akDqnpB67qOZ59Har+cM4xRH7dF36E+npe8JwjXZF6oXTgfd42KvWYmn4+77mefY1QfzjnOEZ+3Rd+lPp6XvCck81P/aZ04H0uNz71xJp+4Kqe/9nXKPWHc44T5dd94cerr88J+X/X+H/V3tE5of8/tvt0PlP1/297p8CV9ODvk54/R4Tn34lkYb/U/dub9djn/z+Of1dyW+obNf3Btfr/6uDs7z71h2v172GaI/+2Auf5vKH8fl7BH5N6euoZ0oFHp3fej/VPHbBzz/la+TGHD/TN2Rd6A/z+UXnw2Vuc8w5QLn9/h5/G5+baD8f+I1OP0pyq9i/1PbLA2c8A9W+cO8j/UfLr+wR+Lp+f8/m4dODRGZ56fOoJNf3A/R/VZMn7eJydnHvMlnUZxzF4EbQEDLOpsFJEdLwGKpmkqRBqtjYVagaIDRFR05rFwU4eYKV2mGAeAuygE0QrMMNKgZetMk0FrLaUg4emQOo4hTbBDlt8P/f2fuC35+72ny/j+VzX93v9+N0P7/Nc6pXdu/zvn2uipx6wR4dFu+2RLl/N65+PfjivjxJHn69EP35A575wvE5f+sDvH65N/M3RW6Oz1QeePqOjY6PjCrlb5TFHjtEFzrlGyR/O84xVbjjPO05z+bzg50d/GP2R+sDTZ3J0SvTyQu5WecyRY3KBc65x8ofzPFOUG87zXq658tt78T+N/kz1cNRPi04v5GzlX/KdVuCc53L5wzn/dOX1PYFfGv119DfqA0+f66I3Rmc2zGOOHNcVOOeaLn84z3OjcsN53pmay+cF/7vo49E/qA88fb4XvTU6u5C7VR5z5PhegXOumfKH8zy3Kjec552tufxcwT8b/ZPqq/eJ1M+Lzi/kbOVf8p1X4JxntvzhnH++8vqewD8XfTW6UX3g6XNPdHF0ScM85shxT4Fzrvnyh/M8i5UbzvMu0Vw+L/gd0X9Ed6oPPH2WRZdHVxRyt8pjjhzLCpxzLZE/nOdZrtxwnneF5vJzBd8tB9m2f+d6OOpXRVcXcrbyL/muKnDOs0L+cM6/Wnl9T+APiPaK9lYfePr8Jfp8dG3DPObI8ZcC51yr5Q/neZ5XbjjPu1Zz+bzg3x89ItrP59alc5+/RTdGNxVyt8pjjhx/K3DOtVb+cJ5no3LDed5NmsvPFfyA6NGqr94vU78lurWQs5V/yXdLgXOeTfKHc/6tyut7An9c9EPRIeoDT5+d0bejuxrmMUeOnQXOubbKH87zvK3ccJ53l+byecGfHB0e/aj6wNNnvwPjG207cN+5W+UxRw76m3Mu+uEP53nIuZ84z9umuXxe8COjo6JnuU+Xzn3eE+0V7a1zq5vHHDneU+D2yiV/OM/TS7nhPG9vzeX3IfgLo59VffW+mvojo0cVcrbyL/keWeCcp7f84Zz/KOX1PYGfEJ0YvUR94OkzKDo42t4wjzlyDCpwznWU/OE8z2DlhvO87ZrL9wT+6ugXVA9H/UeipxRytvIv+X6kwDlPu/zhnP8U5fXc8NOjM1QPR/2Z0REN/Uu+ZxY45zlF/nDOP0J5/XzAfyN6c/QW9YGnzznR0dExDfOYI8c5Bc65RsgfzvOMVu7q+1LNO0Zz+Z5M67VHt+VAtkfXtHXmru65Rx+NPhad23Pf/ajn9avF4Qfv/nBrlKvk6/yPqZ/vCfwHcyBHRt/XvXMfePq8Hn0j+pLOo24eOPzh7QNHH/KVfD3HS8prX/g35Ovzgh8XHR/9pPrA0+fo/Bw1MHrIAc3ywOEPbx8456LfIeI8xyHKa194XsfXzxU8+6CrVF99Xkk9+6KTG/rDfV5/Tu4P5zwD5e9+8Cern+8JPHudr0Wnqg+892RnRU9vmAeu7j7OuU6WvznmcU77mhtVuCfw7HXmqL76uTP17H3G67zq+sPV3b99TblKvs4/Xv08Nzz7mh+rvrr3qWefc4Xmr+sPV3ePNke5Sr7Of4X6+fmAZz/z8+j96gPvPdaM6DU6j7p54Oruy36sfCVfz3GN8toXfoZ8fU/g2c88qvrq563Us7+Z1dAfru4ezXlmyN/94GepX49w3cWzd3ki+ttoh/pR5/3VnOh3ozc3zAdXd1/mfLPkb465nBPO839X8zkf/Bzl8/2CZ6/zZ9VX7y+pZ+9zd0N/uLp7NeeZI3/3g79b/Xy/4NnPbIq+GF2vftR57/VQdFF0QcN81ffG+vMo7dmc7275m2Mu54Tz/Is0n/PBP6R8vl/w7HneVD2c92MdDf3h6u7fnOch+bsffIf6+X7Bs9fpHv1Pfv/f6ked92Brok9Gn2iYD67u3s35OuRvjrmcE87zP6n5nA9+jfL5fsGzD+qjejjv1dY19Ieru7dznjXydz/4dernn6Pg2fP0jx6iPvDek22OvtgwD1zdfZxzrZO/OeZxTvua21S4J/DsgwaqvnofTD37om06r7r+1edb/TmV9nH9lavk6/zb1M9zw7PXGap6OO/Hdmv+uv5wdfdvA5Wr5Ov8u9XPc8OznzlV9XDec3U/sHP/uv5wdfdoQ5Wr5Ov8cG2F7zPh2bucrfrqfU57oD6av64/XN192KnKVfJ1/j7q57nh2bOMVX31vqa9zwDNX9cfru6e62zlKvk6/wD189zw7E8mqR7Oe6fjNX9df7i6e62xylXydf7j1c9//8GzP/li9Er1gfdeaXh0mM6jbh64uvurScpX8vUcw5TXvvDD5et7As+e5VrVw3kPNbKhP1zdPZfzDJe/+8GPVD/fE3j2Qd+OXq8+8N4/fTp6bsM8cHX3XM41Uv7mmMc57WtuTOGerOm6R1+MvhR9tmtnbm76LYo+EJ2n+0QdfecWOPvSd64455knfzjnf0B5PTf8a9HXVQ9H/S+jSxv6l3x/WeCc5wH5wzn/UuX13PA7o2+qHo76FdGOhv4l3xUFznmWyr/6/Kv8HcrrueHfld/o2q1zPRz1T0efaehf8n26wDlPh/zhnP8Z5fXc8AdH36t6OOrXRzc09C/5ri9wzvOM/OGcf4Pyem74ftH+qoejflN0c0P/ku+mAuc8G+Rffe5U/s3Ku9fn3vxiYPQY1Vefe1O/Lbq9oX/Jd1uBc57N8q8+Jyr/duX13PBDoyeoHo763dF3GvqXfHcXOOfZLn84539HeT03/KnR01QPV9Xni8v9ezTzL/nS15zz0A9/OOfndfp6bvizomerHo763tE+mr+uf8m3d4Fznv3lD+f8fZR3r8+9+cUF0dGqh6P+iGi/hv4l3yMKnPP0kT+c8/dTXs8NPyF6serhqB8UPbahf8l3UIFznn7yh3P+Y5XXc8NPiV6uejjqT4ie2NC/5HtCgXOeY+UP5/wnKq/nhp8enaH66n019WdGRzT0L/meWeCc50T5wzn/COX13PA3RW9WPRz1F0RHN/Qv+V5Q4JxnhPzhnH+08npu+Nui31d99Tym/qLohIb+Jd+LCpzzjJY/nPNPUF7PDT8/erfq4aifHL2soX/Jd3KBc54J8odz/suU13PD/zT6M9XDUT8tOr2hf8l3WoFznsvkD+f805XXc8P/Ovob1cNRf2N0ZkP/ku+NBc55pssfzvlnKq+/l4NfEX0q+rT6VP+dfPrcFL09ekfDPObIcVOBc66Z8ofzPLcrN5znvUNz+Z7Ar4uuVz0c9fdFFxRytvIv+d5X4JznDvnDOf8C5Y1U88NvjL4e3Rl9U/2oo9+S6NLoimhHw3zmyLWkwDnfAvnDeb6lyg/n+VdoPjifT4fm3+v7sPxiQB64o9s611f3O/VbolsL87TyL/luKXDO0yF/OOffqry+X/BDokOjE6OXqB919NsV3R0dnH/Pvr1ns3zmyLWrwDkf/dr13w14vt3KDzexwA3uuW8Of/zgfL/gp0YXqB6O+tOjX9R51vWHm6o/T/eHc552+Zujr3P677ln9b39y9F10T917cx7n/Fg9L7ofH2fQr33Iebq7k2ca7784TzHfcprX/gH5evzeknf978RfVV94L0HeSS6uGGe6n225r7FuR6UP5znWKy89oV/RL5+ruDZE7ylejjvTVY29K/+Xqu5l3GeR+TvfvAr1c/3BL7aW0R3qw+89yeror9vmAeu7p7GuVbKH85z/F557Qu/Sr4+L3j2C32jB6kPvPcuL0Sfa5gHru5+x7lWyR/OczynvPaFf0G+fq7g2Uscpno472leaegPV3cP5DwvyN/94F9RP88Nz15ikOrhvKfZ0dAfru4eyHlekb/7we9QPz8f8OwlTowOVh9472v+FX2rYR64unsh59ohfzjP8Zby2hf+X/L1ecGzz/hY9BT1gfeep0e0a49meeDq7pOci35dxXmOrsprX3her/ZEXfbNswc5R/Vw3gsd3NAfru7eyXl6yN/94A9WP98TePYgY6Lnqg+890P9o30b5oGru4dyroPlD+c5+iqvfeH7y9fnBc/+5HPRseoD773ScdEBDfPA1d1fOVd/+cN5jgHKa1/44+Tr5wqevcsVqofzHuqkhv5wdfdcznOc/N0P/iT18z2BZ+9ybfRK9YH3PmpkdFjDPHB1917OdZL84TzHMOW1L/xI+fq84NnX3BK9Tn2qfw80fdjrjIl+omEeuLr7MucaKX84z/EJ5bUv/Bj5+rzg2fPcHr1Vfar3rfRhH3RxdGzDPHB192zONUb+cJ5jrPLaF/5i+fp9CJ790A9VD+d92ZSG/nB193HOc7H83Q9+ivr5nsCzH/p59F71gffebEb0qoZ54Oru55xrivzhPMdVymtf+Bny9XnBs0d6NPqw+lT/P6f0Yd80K/r1hnng6u71nGuG/OE8x9eV177ws+Tr5wqevdIzqofzPu7Ohv5wdfd9zjNL/u4Hf6f6+Z7AszfaEF2jPvDety2Mzm2YB67uXs+57pQ/nOeYq7z2hV8oX58XPPuht6Ivqg+893Aro4sa5oGru+9zroXyh/Mci5TXvvAr5bvX96fh2BsNjB7a1rlP9f1p+rBf2hZ9uWEeuLp7PedaKX84z/Gy8toXfpt8I9X7ETz7oUnRC6Pnqh913scdHz0y2rdns3xwdfd/zke/vgWOuZwT7kKdg+dyPnPkq76fFr9Adbzuvdzx/6cfXN193yTlsa+fq1UJuj66IfpCdLX2EnelwYLowuj90R/o+y7q8bmrwDkH/e8S51w/kH/1/qd5Fip39f6uee/XXD4v+I3RzdG/qw88fZZEfxF9uJC7VR5z5FhS4JzrfvnDeZ5fKDec531Yc/nnIfgd0X+oHo76ZdHlhZyt/Eu+ywqc8zwsfzjnX668vifw7/BGkEb7devcB54+j0f/GH2qYR5z5Hi8wDnXcvnDeZ4/Kjec531Kc/m84NuivaN91AeePquja6PrCrlb5TFHjtUFzrmekj+c51mr3HCed53m8nMFf3j0CNXDUf9qdGMhZyv/ku+rBc551skfzvk3Kq/vCfwHogP4uVB94OnzWnRLdGvDPObI8VqBc66N8ofzPFuUG87zbtVcPi/49uiHokPUB54+/4y+Hd1VyN0qjzly/LPAOddW+cN5nreVG87z7tJcfq7gh0c/qno46rvl59K2HvvO2cq/5Etfc85Dvzb9nO381euFz1fwI6Ifj45yny6d+7w7elC0l86jbh5z5Hh3gdsrl/zhPM9Byg3neXtpLp8X/Kei50XPVx94+hwaPSx6eCF3qzzmyHFogXOuXvKH8zyHKTec5z1cc/m5gh8fvUj1cNQPjB5TyNnKv+Q7sMA5z+Hyh3P+Y5TX9wT+kujk6GXqA0+f9uiQ6NCGecyRo73AOdcx8ofzPEOUG87zDtVcPi/4L0WnRqepDzx9ToueHj2jkLtVHnPkOK3AOddQ+cN5ntOVG87znqG5/FzBfzP6LdXDUX9e9PxCzlb+Jd/zCpzznCF/OOc/X3l9T+C/E50dnaM+8PT5THRcdHzDPObI8ZkC51znyx/O84xTbjjPO15z+bzg74rOjc5TH3j6TIxOil5ayN0qjzlyTCxwzjVe/nCeZ5Jyw3neSzWXnyv4B6IPqh6O+i9HpxZytvIv+X65wDnPpfKHc/6pyut7Ar84+kj0V+oDT59ro9dHb2iYxxw5ri1wzjVV/nCe53rlhvO8N2gunxf8yugT0SfVB54+t0TnRG8r5G6Vxxw5bilwznWD/OE8zxzlhvO8t2kunxf8X6PPRZ9XH3j6/CR6T/TeQu5WecyR4ycFzrlukz+c57lHueE8772ay+9D8NujO1QPR/1j0WWFnK38S76PFTjnuVf+cM6/THl9T+D75Dc+yH6nrXMfePr8FxIDpI94nJ2bedTe07mGQxJTaNVUU48M4pABaQmR0GpNNbNqSEol0ioRlJSWKK1T81xBopEgoVQQNUQRraElmqkkiChNFM1UmqSicspZ67ivb63vYq93v+k/d33vvZ/nvp+997P3+3t/mbtWm///36Lg4uDjwXafQJt/5v8sbdf688cKvC+0/wTnFnid2392vMXiEadT+9Y654rH58RdLF9rhtde/P7B44IDFQc+cbqs/QluF+y29mfrbqTHPHQQ3zzrIh754R1XiLddgUfcbuLhu6344zSOzxl3iupSmw+e43dTXPOI6/xrtGnNnxGhrwffCM5s25o3KgvlzuBdwZvWbM1jHHFHFXivF3h3FuKhq5TX+u9SPPuGvyC4UOPhMf6B4IPyX5sf3gLV2/HhvSFdpbzW/6Di2Tf8ZcHlGg+P8ZODT8h/bX54y1Rvx4e3ULpKea3/CcWzb/ir5Q+rt2s9Hh7j/xScKv+1+eGRD77jwyMOukp5rX+q4tk3/C8EN9B4eIyfG3xN/mvzt5xP7VrzHR/e6tJVymv9rymefcPfMvgljYfH+LeD78h/bX54W6rejg9vA+kq5bX+dxTPvuF3DW6j8fAY/27wPfmvzQ+vq+rt+PC+JF2lvNb/nuLZN/wdg700Hh7jPwyulP/a/PB2VL0dH9420lXKa/0rFc++4fcN9tN4eIxvn/vRGmu1jl+bH15f1dvx4fWSrlJe64fXorfNZ/P3Du6j8fAY//ng+vJfmx/e3qq348PrJ12lvNa/vuLZN/zDgodrPDzGbxHcUv5r88M7TPV2fHj7SFcpr/VvqXj2Df/Y4Hc0Hh7j/zu4rfzX5od3rOrt+PAOl65SXuvfVvHsG/73gydqPDzG9wp+Wf5r88P7vurt+PC+I12lvNb/ZcWzb/hnBX+k8S39JeO/FtxT/mvzwztL9XZ8eCdKVymv9e+pePYN/+LgJRoPj/GHBQ+X/9r88C5WvR0f3o+kq5TX+g9XPPuG/4vgdRrfsm8z/pjgsfJfmx/eL1Rvx4d3iXSV8lr/sYpn3/B/GRyt8fAY/73gCfJfmx/eL1Vvx4d3nXSV8lr/CYpn3/DvDk7QeHiMPzN4lvzX5od3t+rt+PBGS1cpr/WfpXj2DX9S8BGNh8f4nwUvkP/a/PAmqd6OD2+CdJXyWv8FiufnivCnBJ8PPqE48IlzXXBE8BLVo1YPvCmqv/PAe0T6Snnt4xLpdV74I5TX6wT+nOCrGt+yPzN+XHD8KuaHN0fz5PjwrGeE8jse/PGKF2jxD5/n38uCi4JvKx7jiMfz8snBh4ITV1EfvKWaD+eDZ33jld88fFknPPt/SP6sD/5k6fP6gs9z8y7tW4+H598flqxifni1v29Yz2Tldzz4SxQvj71b+lFnPUcfFBwQ7BXcUXEZ798Xuge3Dq7M5x+uol54tb9rWOcS5TcPf9YJr5fqYV/wBqh+roN9mNet8HsK/HEax+f+3aN7k/ng1f6eMkh6nNfn3PMRunYCrBP8Z/7+p7at+SMS4MXgrOBjwev1nITx5BlR4FkH8UeIZ13XKz88+3hMeuHZ9yz5834kL3E3ybg1g//I318NTm3berz1/jX45+AjwfHBG6R3asG/ebV1ss4blB+efY2XXniuwyPyZ33U768Ffa7vn1U3r+ep0vlmcE5wmtaz/d4THBe8UXqmFeplXm1dretG5YdnH+Ok13nh36O8PlenKe5rwen6ncm67giOVP7pBT/m1fqeLl2lvNZ/h+LZ9wvhzQ2+EnxRvkdn/O3B24I3Kz/jiDu6wJtb4N0unvXcrPyOB/82xfP+eFH8+cG/BWdpfzjvhOC9wTHSM6ug27xaf9Y1RvkdDz8TCvHs9175cr1mh/ducI0EWpH/fkn1GpsAvw3ODD4ZvEV6GE+esQWedRB/rHjWdYvyw7OfmdINz36flC/Xi7zw18349YIvq17W91Lw5eCt0vNywZ95tXWwrluV3/Hw81Ih3qf8ype/P7Ju2cfzgm8F39G6Zpz3+d3B+4L3a13X9otm99M86bceeG/Jn/XCs98J8uN48O9XvE99T9e5uCT4dvAvOj9avqfrnJ0UnBj8lc7D2vOo2XP9Neks5f2LfFmn81KHSYW8rtNE1cH3Y/o0/fW94EfBj9XH6GuMd39/NPhccIr6lPsf8XxemFd7rtT2Xft9tBDP/n8rX/Bct+dUD3iu6xTVy/uA+yH38/8EP9B6YH0wzvf9Z4NPaT00ex9t9vtF7bq1n0nS67zU4dlCXtfpKdXB5yD9i/70b60P1gt897mnNd9eR43uMc3209r1az9PF+LZ76Py5b5BP18cfD+4Mvih8qKD8fT9h4O/D/4h+IzyN3uewEMffOdttk7vy7f1w1uputgfPNfpafl3PPjPKJ77Bv2f/cQ++N/g0uDf1Td8XrBv/hh8PPgb6Xtb8fh8oniNzid4f5fOUt7avrFU/u3H8cx7qlDn9zR/zM9aCbhx8CPV2fuL+Xwh+IbOhdp92ux5VLv+7OuFAs9+n5MfeK7PG/LvfsO80Nc7ZNzng+0JHGT+GO/+Pzs4Jzgj+LzWe+26qD134BGHP5Ty2u/sQrw2qoP9wHO9ZqgO8FzfOaqbz0/WB32qXcZ9Lsh8w3f/mh58Reugtv81u07RR1zrgId++NZpnvO+UqgX9xiek34xSN2Zd/h+LjtP8+H1UHtPqn3+W7sO7WdeIZ79zpYv14t+Qr/YNNgl+LHq5b4zP7gk6Pt7o3t5s/3NuqYov+PhZ34hnv0ukS+fS+xv9u9WwY7BLYLrt2s9zv1gQXBh8K3gq6vYV9orL3FmFOKhe0Eh3vryU9K3hfzbDzzXaaHq4HOJ/c7+3yi4ebCT5pf5Zrz7xOvBvwUXaZ69Lhr1ndrzFt5G8mNd8DaXX+tudn27TvPl33nhL1Je7wP6C/2mc3A7rS/WG+PcjxYHl2k9NHtu1va/ZveB/S0uxLPvBfIFz3Vapjp4H7yr/kmf6hbcJfhV6qx94Ocq9LflwdV43yI4U3prn9PUPkev7d/2Q7y1/b6J6rG8EM/1wvdy8VxP8sH3+cm+2TbYI9hd+wk++2lp8P3gv1ZxX8IjP3zngWddi5QfXg/5sl7ziPsv8dw3uMfwe/ZmwZ21z9h3jPPv3W8GP9b+8b5s9Ls5vNr7lXW/WYhX2zfs/2P5g+f6LJZ/13lTzTPzs5P2SxfV2ecD8/mR+ob3V+050+i+1ew6rd3/9r1cvpwX/kfK6zrT7+nn2wd7BrcOdlSdfT58EFwR/EdwofQ1ukc1ex51lM5S3q3lyzqdlzp8UMjrOq1QHVznFTpf6M/fDh4VXFd19u+09POuwU7Bl6Sv0e+98Gp/D609z+yDeJ3Es/+uOsfhuT6d5N/3Dd5H4j2w7wZ/EByk/tfSXzPe75dtnzy7BbsHS32z9n212vem7AM9jlfb1+0fXnfV3fXqrjrAc335HJ3eB/R/zoPewa9p37EPGefzgsDrBEv7tNF9tfZ8arY/2A+8dVQ/1wFfzus6EadNoc6cA9xvvhLsE9xV5wTjfP/5T7BtEqwe9LnT6B5Vez7B+4r0Ww+8PvJnvfDsl7yri+f68HnbQr/pqXlmfvYMfp19EdxB/cbnBvPaIbgu+oL/bvIcgtdT+YmzYhXX7Q7yVdK3m+pgP85L3Tpof8NzXddVvbwPuC/tpHn9RvCbQb43Mc73K9bBesEN9b0KfbX3tNrvc7Xr1j5Wk07Hw/962tfwXJ8N5Z/1y/dC3r8+Jzhc5xbnWMv7iwmwV+LtrXOj2fe7zUMH8c2rPVftY3vphWfffL5XYV1yP+Je89Pg/wR/zvxoXfo+tX/woODBQb/31uh9Nni19zfrI97B4tkfeh3P/g+SP3iuz8Hy7/7Meqev7xHcDz3BA7QvGO/+v1Zwg+BGwY21P2rPk2b35R7yY13w9pNf64Zn3+vJD7z9VTf7N4+4G4vn+eEeyj3ze8EjmN8g95+dNT++v+4Q3Cq4qe5JvlfVPr+ovTfX3ufsq4308mfXYVP5g+e6baV62Ad8PseH+1Rv5T8keGCQ85jzm3H2s1lwE53XPt8b3XObrV/tvcJ+OkgvPPvfRP6sD/5m0ufzc0/FPYjzK8h9B771fTH4Od8bFb90b2q2Dl+XvlLeveTHOp3XPPJ6XdKv6DNHB/sHjwxyf2Gc+1vnYJdgx8K9qdF9qNl+an0bKr/j4a9zIZ59d5QveK5TF9XB65J+/q3gAOlBH3z6/H8Ft1b80rlSOi/gkR++8zRbrwHyZb3mOR68dcJjfe6ieWU+hgZ/Ejw3yPMtnocRx/d35rN3cN/gPsHS87NGvwfBq/3+UPvcrnZ9uz69CzzXq6v8w3Od91Xd4Hke9lFdfU+hP9HPjw8ODh4TPFR9jPE+J3oEewa3CW6ufl7bH5s9nw6S3lJe++1RiHeo6mA/8I5R3ewfnuvbU3XzecB5y/3ntOAp0o+flt+ZdJ/qE9xF+Zo93+HV3t9q62x/fQrx7LuHfMFznXZRHbwP6IP0xYHBIcGTg6fqnGG8+2e34E7BnYO7ruL5Vdu34VlnF+WHN1C+rR/eENXF/uCdrLrZv3no3FU874Mj5YdxpwfPUL9lnO8L5Okb7Ffoo7X3jto+Xzsf9tFbOh0P/30L8VyffvLvOrOv2Dc/DA4LnqD+xTjvwz2Cuwd31LlQ2w+b3feDpbOU9wT5sk7npQ57FPK6TrurDr5/0u/4vnpj8EL1Qfj+3jsoeIj6GnpqvzfX9l3rHFSIZ/19pBOe/R4iX16X9Iuzg+cHz9M+YF8wjn7yjeA3g/tpH3jfNOpP8NAD3/ma3a/201d64Z2vetifecTdTzzX+RTNH/NzVfBy7QfG+XxlPo8OHqH9gL5G53Sz+7B2/dnHHtLpePg/uhDP9TlC/r3/T9e8XB28Uv0avtdB/+BRhfOhUd9vdr1ZVz/ldzz89C/Es9+j5MvrcpjmizpfEbwoeKbWpfsw83Jk8NDgV5vs5/CGKS9xdl/F9Xam/JT0XST/9uO85pHX9+ChmmfmZ2zwruD4IN83Ge/7CvN6UnBY8NTgvtJbe/+p/T5cu27tZ1/pdDzqcVIhnus1THWA53qeqjp5H7C/6OuXBa8J3qD9xzj3/W8FBwQHav/Vnh/N7vvLpN964F0jf9YLz377y4/jwR+oeB3CYz/w+x7PZXieckHw/uCDwd8Efxbkdz/i+f0unsscGBwePC94bvCAoH8vbPT+GLza3ylrn0O5DgcWeK7D/vIDz3U7QP7hue7DVT94npfzVF94nrdzVX/vO/oo5/yo4MjgteqzjPM9YHDw+OC3dR7V9m14je4d8K6QzlJe+xtciHet/NsPPNfpeNXB5w/3Lb4f3BL8VfB26UMv4/09Ykjw9OBpym9ftfe9Rt9fmq2n/Q4pxLP/wfIFz3U7XfWA57qepnp5H9BHrw+OCY4L3qo+yzj67HHBE4OnBE8u9G3ykNdxavs7vDHSbz3w7GOgdMIbpzrYl3nEPVk815l7xtXSwfg7g2NVZ9+jrfuMwj2k0X0cXu39p/Zcrq2z/Z4kP44H/wzFc7+hL7Gf2AcTg/cFfx28Sf3G/Yz9c07w7OAPg99tsj/CG6n8xDlevNr+cJN8lfS5HucU4v1a9bJveK7r2aqXf3fk/TTeP7st+GTwmeDjwTuCvLdNHL/fNjR4efCq4EXBHwSbfS8cXu37dda7m/I7Hv6HFuK5PpfLL7xP1Uv+4bm+F6le8DwfV6m+vl8Pkm90PBX8Y/AxnYuckzyPJJ7f48fPFcFrghfqHCw9x2z0PhG82n9PUPv8tHY91N4XXL8hqoPzUv8rCnk9LxeqvvA8j9doPnze0bc5J+8NPhB8SH295bmwztEfB38SPL9wTjQ6j2vPE3j3Sr/1wLOPM6QT3gOqg32ZR9zzxXOd6efc+/4QfDY4Wf2ecb4XXh28Nnix+jj6Gt0vmz1nrPvqQjz7OEc64dn3xfIFz3W6VnXwvWKs5pn5+V1wevDpIM+BGO/7DfN6aXBk8MrgMOmtvS/VPqeqXbf2M0w6HY96XFqI53qNVB3guZ5Xqk5+/s79g/XB/P8++HC71nzfU1gnlwV/2uQ9B959ykecs8WrXc8Py0dJn/1epnjuG/SZR4PTgjM1j8wr4+hDPw/eGLxJ81jqf6W+Bg898J2v2fU2TT6tG559Xypf5hHX/l1n/r3FrODs4Iwg97vhqjP/HmNMcGxwVLB0X2z07zvMQ9eYAq/2nmo/Q6UXnv2Pkj94rtdY1cP7n+eJLwTfDL4Y5DkifJ4zjg7eE7w56OeLtc8rrWN0gWddw5Ufnv3cI93w7Pdm+XK9eD7L89LXg/OD81QvP8f9Px84tFR4nJ2cd9CV1bnFFQEFBESJoojiJJYQE41iF8WGioI1ZjIpc/9JM8ZozKRZomKNBTWa6LUhMYo9YIkx0dBBQFCUoggWuqaAKE3Knbl3/b6Z73ez79nn+s/6OHvt9TzrOe+73733u48jttniv/97PPhYsO3/wBaj8scVwVPSfol47xV4Jb0FwREFPdrfb9s6vxHi0U78x+SnQ3hbBy8J79Lgg8HXgouCM4NXtm3df0B0TwyeH7w7+GTwnuCpype45GE9eJcoPjoDxHtQfpwXvCvlq5Sf63F3Qc/1elJ1gOd63qM6BbZoH3wxvEnBd4NzgpODo9u27ndthG4NPhp8IHhb8NfK70Xp0X6teOQD3/HgjVaepbj292hBb7L82w881+kB1YHrt13wct2v3D9Lg0PatuYPjI7v65HBQcoHXeK4P7zLFQ+dgeLVji/Of5DytB78kdLjuoI/RPxlwavatuY53qjgYMUfov6DC3Ws9eN8Biu+9eCPkp7vx5fCmxJ8K7gkOC84VffjdRG6Pfhg8I/BPwTvUH7EIa514L2kuOhcJ95byt/5wJsqP6X8lqgO9gVvnupk367z38J7NTg/+E7wg+B01fn6CP1n8OHgI8Fngncqv79Jj/brxSMf+I4Hz/ndqfjw5sun84b3jupgX+YR/xnx/Pzn+fZIcFxwefBfwdl6DtKf5+BFwZuCTwf/HBxWeB4SlzysB6/2OTxOfpyXefh8usCz77vlB57rNEz+4bmuf1a9/FwaHt6M4Irg34Nj9Fw6Lzp3BV8IPhe8QfkMlw7t54lHfPiOA8953aD41sPPCwU9+31OvjqGx/gxLLy/BP8Z/DS4Prg4OIH7qW1rnXPzx9XB54MTguODTwWHBi9U/sOkT/u54pEvfMeH97DyLsW1/+cLeq7DUPmC57o9pTrAc70nqH7w/H2MV339PHgovL8G1wY3BP8RHKvnwQURuiY4Njgx+KfgjcqPOMS1DryHFBedCwp65D22oGcfNypPePb9J/mC5zpNVB38PJig77lNBpYOwXX5nPk183b6+/qZFnw9OC5Ymt9PkC7tQ8WrvW5r1xX29ajydVzqMq0Q1/UapzrAc31fV918H4xMx9eDbdOvU3BjPn9G98HFEbo3OD04KzgpeJnyGyk92i8Wj3zgOx4853eZ4lsPf9MLevY9Sb7guU6zVAffB8wPmL8xn1oT7Bqd9kGe6/RnHuF535jgm8FX9fwnX+KSh/Xg1c5jauej9vO08rQe9RhT0HO93lQd4Lmer6pO/n5G6Tri+98y/bcPbsrnC/T9sL/m629q8O3g5KD32YhLHtaDV7u/V3tf2M8I5Wk96jG1oOc6TZZ/eK7r26qXxynmHxODm4Od0797kPkC/Zif3BJ8OTgnuKAwnyAOca0Dr3Ze5LxfLujZx/PKE579z5E/eK7PAvl3nZlXjEcg/boEPxNcqzoz77g5OCU4N/iO5gnIE4e41ml2vuO8pxT07GOs8oRn/3PlD57r8478u86sZ1iHtEu/XVh4tWvth35e/8wILlJe9jtG3yvtXr/Vrrdq62x/Mwp69j1FvlrCqU6LVAfXmXkv89qt0q9nkPtooursefIrwcW6z3z/jpUe7V4P1M7La8cN+3uloGffL8sXPNdpserg5yf74sx3mafukP7dgivz+Vw9P72fzvx2fnBe8C/B4cp3jnRpf0C8Rvv48NAh31Lc2nk+OtTBfqxH3eYX9FzXeaqX7wP28VYHd0q/HkHmVczD6Mc+3+jge8H3Ne/yPK3RviE88oHveM3OD/GFrvOGZ99j5Mt68N+XnuvMPtSs4Lbpt1twm+AK1Zl9qvuDs4PLgjODLyg/4hDXOvBq98ec9+yCnn28oDzh2fdM+YLnOi1THVxn9k/ZH905/foEd+T5oDp7v3Vh8OPgu8EnlV/tvm3te1vnvbCgZx9PKk949v2ufMFznT5WHbxf/EY67p0P9gnyfXG9wL8vOiuDH+l79HWEPjq031fgkcfKAq/2+rWP2coXnn1/JH++LllHsf7pnX67B7djHNF16XXXB8HlwbeCjyu/2nMctes85/e44lsPfx8U9Oz7LfmC5zotVx18XbKfszC4axq+EGR/Bj77PE8ElwQ/CU5XPugSx/3h1e4rOc8lBT3nP115wrPfT+TL8zPOhzCOME58PtirXWtd8qW/z5UwvqwKLlV8+5qp74v2e8RrdJ6l2XrWjp+ux6oCz3VaIv/wXNelqpevZ54HvMfrmIYvBnfW9ez3gW8E12g8J5/a94m1zyXn+UZBzz7WKF949rlQfjzOcr6EcYrxZd/g1tRd46zPrzEerQ6+FvT5j0bn4OA1OvfS7DhrHyOVJzz7fk2+HBf+asV1nT9Mx1XBz6bf/sHPMY9QnZ+N0IvBfwTXB/8ZfEn5EYe41oFHO3HReVY88kXX+cBDBz+l/PCNrn3B+5zqZN++//l++f6+FNyP+bDmWb4O1gbXBZs9l9Ts9ea8Rim+9fCztqBnv+vky/XivRnve/um4eAg78Hg+/3yJi70PCinKZ/a99O17++c56aCnvOfpjzNsx48P/95/8L7kAOCJwUPDDJeM77T3+9tNgS3T6CNGtebPacCr/Z9Ue3zx343FPTsH72N4p1U0Nte38+Bqq/r5O+HfVLW06yXDwueETyU65rxPv19joV19lYJ1DPYJjhDvhqdi4FXu59buz9gP+i1UT1dD3yV9KiXfcM7o6AH389B9lc593B0+p0VPA6ddq37+RxFh+j3CnYOviIftecxavd9nTd5WM8+0Ous+uHber3EO051sm/XmfdevK86JPj94FFBzvvQz+/Jtoz+gcQJTpDf2vNFte/lnF/L+SPVxf7I13rfL/AOlN5RqpN9u87sM3NO5Njg+cHDgzvoeva5k22jfyj5BOfLR+35ldr9b+dNHtazj5a8Ovx7Hv7tB975hbjwPa7z3pxzImcHvx78dvA0vl+N6z5/slsC7BncL7hzcKr81763rz334jzR21l1sl/yLulRB/uB9/WC3p7ifVv1dZ18H7D/z/7+QcEfBk8OtpwnST+/L9gcPCRxdgi+Kb+151dq3084P/R2UF3sb3NB74cF3iHSO1l1sm/XmfdU3Ifcb98Nfi24h+rs91rcj18Ofjb4oXw0ej8Gr5viojPv/zmO7CE/pfy+qzrYF7yvqU727fGG8wycQxgQPDf4VT23mRfQ3+cgtkuAvsE9iFuYPzQ6Hwqv9vxF7bzFfsnbekerDvYD79yCXl/xvqr6uk6+D3ifuFdwYPDHuu+4X1v2uyK0Itg9+kcGS/dzo/eX8MgHvuM1O44MlE/nDe8g+bcfeD9WvezfdWbhzzmRU4IXBU8MdlGdfe7kM9HvF+wWnKv8as8J1Z5zcX7odVP97I98S3r4tx94FxX0+hXqzHsgzvEdH/xp8IRgb9XZ5wK7RL9/sGvwA/moPV9Y+37KeZOH9ewDva6q308Lev3FO0F1sm/Xmf0j1hXM9y8InsP4ozr/r99BRP/wYO/gJvlt9HuKZve1atdFfeWnlB++0bUveOeoTvbtOnMuinNP/YI/Cn4r2Fl19jmqraN/WHCf4Bz5qD3HWXtuy/mht4/qYn/ka70fFXiHSe9bqpN9e/+W9QPz/5/ovuG+hO91xlHB0v3a6Hxxs+uZ2nHiePlxnvB+Iv/25XqxH8N+ymX6XnqqXt63OQndwvfc6Lxfs/tDtddXP/lxnvAuk3/78n3MfiL7gT8LflPPN56fLee3IsR+4THBvYOl52ujc6nN7nfWPtd/Jp/OG94p8m8/8L6petm/68z+OutP1oWnBy8OHqA6+/cYrBt3CZ4Q3CC/jX7XAa923792/XyA/JTyO111sC94F6tO9u37n3kg87grg6xPWP/A93zx1GBpXdTo/Hqz89La9dgA+XGe8K6Uf/tyvXj+8Vz6ZZB91O6ql5+TxwdL+7KNflfR7PO4dj/4EPlxnvB+Kf/25fuY9428V/xG8FdB9jvZd6Wf30/uFTw5WNqXbfQ7RXi170Nr94O/IZ/OG96x8m8/8H6letm/68y5Ls5t9Q9eEWR/s5Pq7HNgHaN/SrC0v9rod4rwas+d1e7r2h/5Wu+KAu8U1fls1cm+Ay3jAOc6Obf5leDPg98LDsIH85T093nQ3RPg2OABwZ2CzZ5nhld7DtV5oreT6mS/5F3Sow72A+/nBb1jxfue6us6eXzeRn7IZ0iQ97LwfW6cPAcFt1I+tefOa98r19b/MPko5TdEvu3H1zPnaDi3dUTwvOAvgmcGOU9Df58Ha5cABwePC+4aXCv/tefLas/72Af5WM9+0NtV9TyvoHeweGeqXvYN7xeqr+vkcZ1zI5z7uDR4YfDIIOcc6edzJidG/4hg++Aa1aX2XGXtuRbnh1571eVS+XTe1sO//cC7UPWyf9eZ84ucEz81eLW+/31VZ5873zH6pwVL11/t+fVG5yqtR97kYb3a++MI+bcfeFcX4p5WGG84D83vRAYHvxO8KnhMkPPO9PfvT3okwP7BwcFOwVXyVXseu/Z3L84TvU6qk/2Sd0mPOtgPvO8U9PYX7yrV13XyfcB1xH40+8mXBC/X900//66C/eYBwYHBHZVfo99nNHt91+6nXyJ/zhfeqfJd8nG56mTfnqf00nXD935N8Aeap/icP9fD6cGDlE+j3wnA+0GBZ73a6/wa+XGejgvfPnxd7qo86X9tkHk+6wP6+XcU6J8RLK0fan+P0ej3Ms3WuXZ901/+7QfetaqX/bvO/E6C5zXP2+s03vRRnf27Cp7HZwZL412j3w3Ca/Q7jmbH2dp5yXWqg33BG6w62bf/v6T8/u/6IOsg1lnw+D3gWdEprbsa/Z6wFBdd82rXe18p6O1e8M18m/nyr4P7ybfn42cH/TuARuf7m53vOx/0zi7w0HWe9j06vPXwQ+jVXrrpPz64JLhU8dFB1/1axrH2/55X0iOvJQU9571UeXo8mcD8LR8cEdw92CM4T+PJ0Oi9xrwz/wPF5fn3+8E/KD/ioUf7UPHIB77jwUOHPEtx7Y98rWff6C0Xz3Varjq4zhOTZ4d88PngPsGNaX9Hdb4luq8zX+Y+D04KPqL8JkqP9lvEIx/4jgcPHfIsxbWfScrXcanDqkJc1+kj1cHztkn5Y6vw9w5+ObhA87Zbo/MK42zw0+AI5YM+OrTfKh7x4TsOPOc1QvGth5+VBT37/VS+XK+x+WNZ8ID0OyTYvX1r/o3RGRXcENwy1/0C5YMucdwfHu3EQ+fGgh55bijoOf8FyrPl/Z780r6hUK8x3J/hfzHYh+eE6nVDdF4NrmG+E5yuvNFHh/YbxCM+fMdpmW8pr+mKbz38rCno2e/H8hVoqdv05Pem7huuz77BLwU38TxK/zsj+Hvdj1zXm4Jrg5OVL3HJw3rwaCc+OneKt0B+nFez97V9T5YfeK7TWvl3XPibFNfPpfGJ2yUf7BU8mvsr7R/quXRz9OYGV/D95/6ZmH8/q/zGS4/2m8UjH/iOBw8d8izFtZ+JytdxqcOKQlzXCZ2WOoTHdTyV9VH4+waPD+4W7BlcpPvgjgguDK4OdkncZfn34uCTypf46NJ+h3jkB99x4aFDvqW49ru6oGf/6C0Tz/Vapjq07KOqvrQT3/fBtPhZHNw+DccGDw92bN+632+j91Tw7eC25BN8Qz6IQ1zrwKOduOj8VjzyRdf5wLOPlrxUP/vHj/VcH3S2LcyDxyW/bvmgf/AEnpvBzRpvbkrcecGO0e8anJHPX1Z+xEOP9pvEIx/4jgcPHfIsxbUfeF1VZ9cBX47rOqED3+PNG8nz7eAu6feF4JF63vP8p/99EXwouCj4SbB94pbmCcQlD+vBo5346NwnHvmj67yance4Hp8U9FwvfH8inuu5RnXyPPLl/LFN+P2Ch/J81zrlN9Gbybw0um2CY5UP+ujQ/hvxiA/fceA5L/Ta6Hq2H/K0nv2is3Vh3Jis9SfrweP0vOb5Tb/bEtfr0M56Xvv5ThziWgce7cRF5zbxatfFtfMP+14hX44Ln3bius5zk9+W+eCg4IF8T8H5Gp+HR29qcHNwY3Ba8GH5IB56tA8Xj3zgOx48dMizFNf+Nhf07HuafMFznTaqDq7zFO1bsY90svLaUtfz7dHzvtQOHf9vH1P0vdJ+u3jkA9/xmq1f7X6a/ePHPNdns/x7nJ2ZP7qGv19wAOO0xtl7ovdmcF1wu+iPUT7oo0P7PeIRH77jwHNeYxTfevhZV9CzX3Tgu16v5I/O4Q8Ksq/EPhT830VnTnCn6Jf2p9BHh/bfiUd8+I7T7L6Y/ZCn9ex3pXz5Pn6d9xDBPdOwv9Y9rIPod290xwX/FVwfLK2TiENc68Cjnbjo3Cse+aLrfJpdx+EbXfsyz3rwXOcZGtcZZwfqPuiqOt+l5w/jcnfdB75viENc68CbofEFnbvEq32O1N7X9r1OvhwXPu3EDbSMA+/HzxLtQ7Lfd1bwmOC2Wjc8HsE/Br3f2CvxOwVnyxdxycN68GgnPjqPi0f+6DqvZvdJ7Zu4nVR31wvf1nM90elVGG9ei49O+eCw4OAg70s66D64O3FnBbeKfo9g6f0L8dCj/W7xyAe+4zX73sf+yNd69o1eD30frhPt6Po+eE/7W+w3/UfwHOYpwb9rv+6xCHofq0/i9Q7Oz+fPyRfx0aX9MfHID77jwkOHfEtx7Qteb9Wzdr/OdcO/ea4r8foU7oOFWt+yjjwjyHsd3hfR74nE9fq1p977+H0S8dCj/QnxyAe+4zX7Hqt23W3f6PUUz3WivU2hzrP1XoT3D2cGOW+wXnUelvh+n7Fr4pTOLxAPPdqHiUc+8B0PXu25idr3MPa9RL6s18Lv2FrP8+5Z+ePE8E8Kcs6A8wvw749Ot+huHyyda0AfHdrvL/DIA33zas9T2Ec75QvPvmnvVhiflybP1Vp/sc45W88Pnif0HxnB0UGvs3bT88HPHeKSh/X+C+PMDnd4nJ2ce9RQZZnFP28gH6KC3ARUBJfKPUFTExW0JpWLIKLimgY1hZrCELSpZrxUVt51zZSmlmtQVETTZd4IarQUJsVLjiikpqB4w0sqghiC84f7x1r86l3nHP1nf3xnn+d59j7nvZ73c+uWT/97bZtPsX2bT/Hpdp/incGtw/swvLXBB3L99+L9U5vN+VzfsXVzHvkODG7Vunl+eMcWeLsqHnnhc52824aXyy1LU992+cXI4MTgwcFt22x+36zU90ywfeLvFmwb/D/pIB/xuD5LPOqB73zwtlWdpbzoIq7rhmfdbaXL8eBzvX3B52ejozW/+ELw+ODng13k8+zUuQQ9ib97sCX4ovSSh7x/F0d1kZc4s8WjXuK6HnjWQbwW8ay7RbqcF/6m6wWf34mej4OH5sLRwXHBbvJ5XupcFGyX+DsHewRXyBfykNdx4HGdvMSZJx71Etf1wLMO4vUQz/rR43j2p4f02+dVem94jocEe7fZ/Ab+eXfq9HuxbXBVfv+IfCEfgbh+t3jUA9/54LWozlLeuu9zb+m3Hsczr6Xg8/Lo2Cm/OC54SnAAz0s+z03evwR7J/7A4Jr8fqXqIw95HQce18lLnLniUS9xXQ+8HtJTqs+64Q1UPPvE9d4Fn99Q+6QdfDU4IthRPt+V/G5/g4Ktweekg3zE4/pd4lEPfOeD11F1lvLW7Tesu1W6HA/+IPWXNJe2wfXR0Tn8/YOnBk8Ojgl2YBzO/QsT8IXgFskzODgg2C24VPrJT1yuLxSP+uA7L7wOqreUF53Edf3m4Qe6zLNP3aQfnn0dIL/wle51m/C+FDwteFiwU5vN+U9Exw6JNyS4XfB5+bCN4nD9CfHID9954HVSfaW81rGd6nVe+FzfodBv7Jgfugb7BEcFRwf7qt94NvUtD74V7JI8XYNvSwd5yOs48HZUXuI8K14f1e964I2SPtcLr690l3TYH3hdCu9lr/COCZ4QnBTcRe/lq8nXK/H6BPsGX1M9vRSH66+KR374zgPPdRGvr3jWQ52OZ719pcvv5W754aDgEcEzgv8aPFLv5Rupc5vE7RQ8KLhvcCfVRx7yOg683ZSXOG/I5yNUv+sxD10HFXjWu5P0wLM/+0q/38tdw/ticEpwZvAkvZevR+f2ife54MHB/qqHuOTx/fB2VT7ivC5fXSf5Hc/191ed8Kz3YOnye7l3fugXHBv8dvDM4OF6L9+PjtXB7ok/InhIsIPqIw95HQfe3spLnPfFG6v6XQ886+igOh0P/ehxPPtziPR7njWQ5xucHJwa/LreA94L7l+bgH8L9kuefYLD9Jz9/pCXOhwP3kDlJ85a8SZLj+tq+n5PlS/WB88+fU76HQ/+MMVzO9hT7wfP9ftB1uOs37nv3ej2+zRK63Wv7/dUPK6/K5+pB77zNd1XqNsOrHtn6XI8+KMUzz7vlR+YJzMP/jf69+A+8vm96Pa8emRwY66vl397KR7X3xOPeuA7H7x9VGcpr/XAG6l4ddcN9mmkePa5f34YFBwe/G7w3OAE+fxB6vww2CbxDw8eGdxF9ZGHvI4Dr7/yEucD8YarftdjHrqo0zzr3UV64NmfI6Xf8w32PdjXuED1UB98748co/iue4DicH2N/Kq7D1PXL+uhTsez3sOly+PgYLUL3udLgucFmV8zH+f+dQno9nRc8CjNwz1vJy91OB68wcpPnHWfsZ3XXVdYfx/pcl58Q7/z2tej5JefD/uh7O9/LTgj+I3gicx79Hz83WBocHhwv+Ae9Fuqt2o/tun3ikNUbymv9Q4txDtRPlgPPPs2XH7A+0aBt1/h+QwjL/1TkPXR5cGf8Lz1fDYk4CdBr7smBccHO6te8lKH48EbpvzE2SDekdLjupquF627s/Q4Hn5NKsSzn+Plk8fdIcrPfT8K8h2Y78Lc91G7f1zv0UF/N6a+IYrH9Y/kM/XAdz54Vd+rm/ps3btKl+PBP1rx7PNQnkfw0uBlQfZZ95fPH0d3z8Q9PnhCsLS/O1TxuP6xfKYe+M7XdF/Z+qjX8ax7sHTBs08nyAf7fEB+4Ps739d/rrrGy+ctmS8F+R5/ivJZB3nI6zjwDlBe4mwpXt3zA3V9tv5TCvHsz/HSb585R0I7oR1cGWS/Yax89rkT2s1JwdL+xYGKx/WtxKt7zqXuvknd/sC6R0iX48E/SfE8fnJ+ge8OfFf4TvAHmgcwL+B+zjn4e8VhwdEa5z1/IC91OB68qnMWTb+j1J3f2I/DCvHs01Dph2dfR8svPx++Q/xzcFrwrODpwa8QT8+H7xV7BvcPHho8ILhXsKvqrfoOAo/64DsvvNGqt5R3mnS7fnhfkQ/WA+8s+Wcf4J0uf+2T+ynOWbGOZp18jfpF+knu4xyW192nql90P0oe8joOvKrzX033Aer289Z/aiGe/TlF+u0z3/n5jn+D2iXt9Evy2ecCpqm9+fsp9Y1QPK63ilf3HELVd1vHQ9+0Qry6/ZJ9Okw+4JO/47E+/nGQ73qbvsvmftbP44L+flj1XbDpOt/19FV+x4M/TvGs+8v5xVVBvrMdId0dc//JwdL3vC/rfq53LPDIe3KBV/c7ous/SPV6fGE/m/3qucHZeg95LzlPw/3eBz8zeLreM5+7od6qc31N99+rzvs0bWf25cxCXvs1TT7As7+ny7fApv6Pc2J85+Q75sXBm4I3B9l/ZL+SOJwr83fSicHpwTOCpf1N6qAux4VXdb4NXt3vuHX3X+3PxEI8+3WM9MOzz9PlGzw/hzPkq8czvl+wPmX9eWuQfUr2NbnP56NYr54VLO17Vp2zqvtdpen6uu6+rHUfJ13OC/8s5bXPfPecHjwneH7wh8Gvy2e+i34heERwbHBMsOl3VnjUA9/54Lm+YcoP7xzpdN3wzpcP1mUe+ceIZ59Z97CuuSh4YfB7wRny2eukY4MTgl8MDld9dfeT667LZqjOUt7vSZfrdF58OLaQ1z5NkA/2eYreB57Pz9TvzZTPPhfA85ys/sz9ZN3zBVXnbJq+z3X7ceufXIhnfyZKv31mP5x5FPOqx4J/Cl4un30ei3nXVcFrgpNUX9W5rqb79FXzQHjWMUl1Oh76ryrEsz/XSL/nn5yXYF+LfasVwbeCzJuYj3G/zxmx33Vr8F7Nrzxvqzq3BK/qXEfTfbq680r7cWshnn06U/rh2dd75ZfbAe2L8eCnwauD16r9cZ/Hi38JfjV4mtpf3XGnabv/qep3PfCulj7XC896J0uP48E/TfHsM/0/48EvgzcGfxG8Qj57vJga/FZwSvDEhuMOvAuVlzgTCvGoe2oh3hXSU6rPuqdIFzz79C354P6GfRDWaazD7lb96GEc537vn7B+O0d5S+N91f5v3X2bzzrPqHo+9mGq9DVd79rfc8RzO2DfhnUA8/wXgs8G2dfhPp/jYF0wJzg72HSfCF7VuRF4rm+c8jdd71j/nALP/syW/sAmvzmfxPqXdeujwXeDf2UcD7K/Sxyfb2Lde2VwfvA3wdJ+cNU5M3hV56ua7kPX3QewD6dKl+Ph45WFePZ5vnyD5+fwG/nq9sP8lvGJ8ecWxvsg+xXc5/kw49XM4HnB6aqval7ddB+l7vhqXTMLPOudLj3w7M950m+fGd+vD94Z/LXqulY+M/5/M/jvwf9QvqbzCXjUA9/5mvp3p3S6bnjWPVO6zCOu9Xu85ns252FYp7C+eCfIvJb58qb97cT1OSXWJfOCpXl11TkceFXf3eFVnZ9qui6ruz6wX/MK8eznrfLJ7YD5GfOvu4L3BG8LXqd24Pnc2cFzg98Ofk31/ULxuD5FvLrzx+tUZymv9Z1diHeb9FsPPPt0rnzweM25Gb6XMg4xLryteQLzBvZLieNzNx7H7tO8wfur1F91bgpe1bmfuvu68Kq+Gzcdr+vOr+zvHPnlvPDvU163H+bZzI9/H3xA7xvvH/d5Xn5x8CK9R03XS03XAXXbhfWcrXqdFx8uLuS1TxfJB/s8Jz/cHpwfvD+4IHiHfJ6ReN8Jnh+8MPij4HdVH3nI6zjw5igvcWaIN1/1ux54d0hPqb775YN1wVsgn6zbPjP+M87fF/xD8H+C98pnzxe+H7wkeEFh3lZ33lE1v4N3n+p3PfCs4zzV6Xjov6QQz/5cIP32mXbE+78w+BDju8YX7nO7uzx4WfAHGofrjldN2/k9qrOUd550uU7nxYfLC3nt02XywT7fpOfM8/lzkHXczfLZ6wye5w3B0rqw6jty03VN3fVo3ffZ+m8o8OzPldJvn2knvwsuDj4efELtiPtoRz8J/iz48+DVakfURx7yOk7T9rtY9bseeNZxieqE97h8sC7ziHu1eF5PsR/HdwK+A3wU/IvGX8Zj7vd5Fb4fPBi8WeOwx+2q8y919w2bfveoO6+w/oulC579ulk+uD74D6o+twP6JfqppcFlwSeDi9QO3I/NCl4fvDZ4RcP+EN5DykucywrxqHtWId4i6SnV96T0Ww88+3S9fLDPD+aHPwafCj4fXBJ8WD5fmnj/Gfxl8KbgdcH/Un3kIa/jwHtQeYlzqXhPqX7XA+9h6SnV97x8sC54S+STdbu/YVymPdFeXg6+pPeF94f7Pa+nnf0qeJues9+zqnVC0/lD3f6hbjuw/lnS5bz49qtCXvt6m/xyO2A8ZzxiHFkefE7jPfd5fsq4Mzd4o8b7uvPcpvOMuuOpdc0t8Kz3BumBZ39ulH63A8bpZ4Krgm8GV6o+6uV+xvP/Dt4dvCd4u/KX5hOleQI86oPvvE39XCXdrh+e9c+VLnj263b5YB757dff/X+G1W7eC74ffEXjC/e5vS4I/jZ4h8bhuuNV0/5hmeos5bW+BYV4r0i/9cCzT7+VD/b5OT1nnuPfIOSFXy+f3b547g8FHwkubNhO4a0v8Byv7ntqXQ8VeNb9iHTBsy8Lpds+v5gfXguuCW4Mrg2+Lp9vSbw7g/cH/xh8IPhr1Uce8joOvBeVlzi3iLdG9bseeK9LT6m+jfLBuuCtlU/W7f/fCc+Z/mZdcIOeP3z3V38I/m/hudft7+q+b+tUr+uAt0F6XKd5zgvP4yD7AYyvtDfe6+1D/Dj/5vs393sfwe10WXBRcL7qrdqXgFf3+3zd+ULd/sW650uP4+HXskI8+7lIPvl9ZnxgHrlFCFsF39P77Pnl4uBjGgfqzk+bjlOuc3EhnutfoDrhWe9j0uV+lnk56/stc1/XtpvHo07u837Bo8HlymcdddcBdfcn6vpnfY8W4ln3YumCZ5+Wywf3Gzw3nkv7YGtw6+BqzUe438/76eCS4OPB32n+Vnee0/Q9Iw71lvJyHX2u03nx5elC3q3lm/XDs79L5JvbAf0/40G73LddsAMPou3m93m8eCr4THCp5jl1x52m8yvqJa7rgWcdj6hOeOgmrnWZR9yl4tnnT+hHwu8Y7BLsFGwrnx9OvD8Fnwu+GHw++KTqIw95HQce18lLnIfFo17iuh54baWnVF8X+WBd8DrJJ+u2z+v13vB8dg72CG4vnz0v53m+HFyp8bfu/L7puF/3PbWulws8610mPfDsz0rp93yD/oX+pluwe3CHtpvz3Q+tCL4U/HPDfgxeq/IRZ0khHnWuKMTbQTpK9VnvS9LlcZBxlXGzT7Cv6qJOxgXu93j8VvBt5S2NH1Xzo6bzgLrjVl3f7ctbhbz2a4V8gGd/35Zvfp/5+6dRuTA6yLk6zuHB5++iurRP/cHS+byqv68yjzqIb17dc4HWAY964Vk318nvfpbxr3OwZ3B39Uv0U9zH+PhC8JXgm+pvSuNyabyFRz3wna9p/9lTOl03POt+WbocD/6biuf3kr8L4Pwa59PGh3iM+ln//QDn2HrmOfbSc6/6+wN45DHP8eqet7MO6jPPOskH3/0s/QLtvl+wf3AP4qj/5n73J6uDHwTfCb6q8avuuNC0H+uuekt5e0mf63RefFldyLuHfLN+ePb3A/nmfmNnvf8DgoODgzQP4T63pzXBdcEPP+O8pmn7dX0rld/x0LemEM/610kfPPvzofTbZ/qZ3sG9gwNV1+7ymX5oVfD94FrVZR3kIa/j1O3/4O2t+l1PU58HygfrMs/x4AU2+b1C4zDj5+Tg2CD7JuzHcL6EOD6vz/jbL9g96P2bpn8nDK/q7wXgVZ2DaTrPqLsfZd/gdVc8+91P8zF4fh7d5a/HEfZdWTfR3ml/hwYnBMdoHPF+rfuJdsm7S7Cb6q3a/4U3psBzvLrrwLr9m31Aj3n2Cb3tVJ997CZ//HyYP3Bun313fCDOScHxej4+3+/9evL313yDeqv+XqDpPKfq7wWbfmeo+17Yp/6F99E+9pQ/fj60W9rbxODI4L5B1mld9Xzc3ncLtg9uzPXSOrFqn7ppP1N3fWpd8DaKZx+43l557Vt7+WEd8LmODnxlndBH+T+veSHzRPjW0ZK4pflj1fq7qV91563WsVr1Oi/8Fr1Xnk/1E/+A4P7BIZoHc5/zbxncIviR1hd159VN9fZXnaW8Q6TLdTovPqDLee3TFvLBPjPvYh42LLhf8EDNl7nP87QNwU+CWyXfOumomu81nacPU/2uB551rFOd8PaTD9ZlHnGJA8/98yDl574RwaOC4zTOc7/XH+RrDXYO9iiM91XrmabzjLp+Wif1mmfd7aQHnv1C9/8DflemvHicnZx3sFXVGcVBQLhwH0elNxURQbGAPLrAo0jvxYZYGEcQhIB0RIoIQqISRWOJGo2KaGyJRmM0mtixV5DeRQSpooAKmQlrvZnzy91zz73558t7e33rW2udvfe53DdJ+Qol/vef0kdLiR5lj9Z+qjW1XllVvy5RRrWZftFOtaNqkWqrsnH8kfJHaznxpVXLq5aCnmbg8bp5jPN84znHuFbQF5rbEb6olzjypQN5tdAvWqp2Vu2k2hp5lRTPMaoVVQusA3rM6znsN64F5pmnZIDPOisG+FrDR0gf/RbAV0o451ao/9JB9QLVvtBlnc3LxvsPax9UEP/JqjUw135KQG8heL1+GPvP+oznXOOaQ29obtLcmYv9cS7zqogcjGO+NZBbOeGOVfW+9znorjpI9UJV3yvu4zmppHqial3cO0nPm3FFmGue8sB1h37qMW4Q/FGvcfRbGX7IZ3xd8PEcdMLz8/MZqnqZ6kWq5+Mc8Jz5uTZQbah6imqU47k1rhPmm6cAuKT78Xz4CuljHg0CfBchL/o2jrk2RF48Bz3wPK9UHak6Au9V93F/NFItVD1XtSb0ZXtP57ofqa8m5pPP/hoF+Oi/EP6MYz7nwj9z9rm5VPVq1eHQdSFy9rk6TbWxahPoyvWcGmc9xnNervldDZ/UbRx9N4Iv4sxL/8y5PfaDn8/vVW9XHYicU9ivfp6XqA5RrQN9nuO55DGuPeaaJwVc0v1MH3Wgk3z2f0mAj/kMgX/fx/5853vL791rVK/FfWY838dNVZvjfkr6Ps/1/qTOpgE+6m8AncbRb3P44r70553BqnNV50GXdbrPn4dOUu2r2g/z6MNzPJc8uX4Oo+6+Ab6kOdN3U/gyjjn1Qw7MeSiey2jVMarD8H50H59zC9WWqmfi80bS922u++oy6AzNHQZf1Mm5zqFFYC5zaokcmLPvbd/P41UnqE7Ee9R9vOfbqrZTbY/3aK7vi6Tv7/HQTz3G0UchdBo3ATnQF3HmbQ8ccx4l3FjVqaqzVKepjkPOzcTXWrWTag/VzqptoM9zPJc8xo3CXPM0A24q9FOPcePgJ6RvFnKgL+OmISf6Zs4j8Jz9fG5QXYj3qPv4uc/Ps6vqxXiPJv38mOv7O+k+pa+uARx9XwxfxjGXS+CbOfuemaQ6W3WG6mTcQ+7zPVSk2lO1m2oH3NdJ7zXirKsogBsDnaG59NcT+o2bDP/0Yxxz6oYcmLPfq35v3gx/9nstcuZ7uD90h94f2T4P5frez/W9le250X8R/FGf8f2hjzn7Pp+uOlP1RpyzicjZ930X1e6qvXDOQu+Z0PvDOOsxnvNyvQ9mwid1G0ffXeGLfMb3Ap9+Xfzvh576xRzVm1Qvd3/ZOL6KeHqr9lE9XbUq9PQEj9erBHDW0TuA6wV9obn0cTr0GkfffeCPefUBr/v8eXow8qqOfMwf+pzfBzxerw6c5xvPObn++yJpXvTbFzifQ97XPvfzcX8Xfz+Le2MA7uFc7/+k9xL19MR88hk/AHz0PQO87lsA33zfmHdgju8pzvUc83TL0zd1DwSOvn3/3Kp6G+6j4u/Z1X+h6kV53mfGeZ7x5DeOenphPvmMvwh89H0DeN23EL55b5v3YsxPet8n/TyZ1Dd1Xwwc78Pe3heq/p7rDtUrcB9WEw+/V7tU9QzoMa/nsN+43phnnmrAJf1+j/rPgE7yGX8p+JhXf/C6b5HvFeRVC7mYf6hqbejpDx6v1wLO843nHOOoqzbm55oX/Q4FjnnV1h++Oqm+HR2tC/TzoFQc/036aC0okG7VgaonFsT1kN995in+3j8Vx3udfNTp+QXAUf+J0Gkc/Q6EL95DzYV7K4r3W5dxJdTfH3zU6T7zlgjgONe8JfLMh/oHQC/3SRnx9lV9M4rzNMc++UTPr4b4DmTRXdyfivcTRx3m/wT7KWle9GOdNYCj3/7wxbyqireH6htRnKcv8lov/ZXF2xf81EN+961HDp5j/Ho8F+Oo0/Mr55kX/R4AL89VF/H+J4r398C5Ok79fZATdbrPvMcFcJxr3uPyzIf6+0Iv90kk3iLVf0dxni7YJyv0/MqLrzf4qZv87luBfeI5xnudfNTp+eXzzJV++8AX86oo3naqr0dxniLk9bV8lBNfL/BTN/nd9zXy8hzjv8ZzMY46Pb9cnrnSb2/4Yl41xHuO6mtRnKcd8tokHwdVe4Kfusnvvk3Iy3OM34TnYhx1ev7BAF+2XOnXOPPyHqov3n9F8X7rMm6X9PQAH3W6z7y70plxnGveXQG+bPlQv3E9AvvkRPH2VH01ivPUxz75VvOqiK87+Knb/Z7jfuKow/zf5pkX/VhnFewT+u0BX8yrvHj7q74SxXl6Iq8vpauW+HZn0eN+z/kynRlHHeb/Ms8c6Mc6awFHv93hi+eqmXj/GcX7++NcHZHuruDjfPeZ90g6M45zzXsE+ST1Tf27wRvy3U/15SjOQ981xdOlIM4b4qsZ8JPUN3V5bk3Mpe6u0MnzUUG8fVT/EcV5+uF8fCVd1cV3Pviph/zu+yrgz/ivkHPx98LQ6fnVgUuaF/12gS/uk8bifSmK9/fB+Tgk/Z3BR53uM++hdGYc55r3EHJMmg/1G9c5sE+qi3eA6otRnKcx9slG6aotvk7gp273e477iaMO828M8GXLi36sszbyot/O8MW8jhVvG9W/R3GeAcjrU+kqI76O4Kce8rvv04A/4z/FczGOOj2/DHBJ86LfTvDFc+X5XVVfiOI8xd8rqP941Q7gDfEdH/CT1Dd1dYAO46i7I3Ryn/yqP/ieIP7nozhPV+yTd/X8Vqt+m0UP+d33LvaJ5xjvdfJRp+evDvBly4t+jTMv8/pF+s4X/9+iOM8JyOsd6YrE2x781O1+z3knnRlHHeZ/J8CXLS/6sc4IedHvt8DzXNUU71+jeL/nGbdZetohJ853n3k3pzPjONe8m/P0Tf3GtQucq0ribaH6XBTnqYl9ska6SoqvLfip2/2e437iqMP8awJ82fKiH+ssibzotx18Ma8j2s/nif/ZKM7TAnktla5jxXce+KnH/Z6zNJ0ZRx3mX5pnDvRjnccCR79t4Yt5VRbvKarPRJiDvNZK/w5/75JFD/ndtxY5eI7xa/FcjKNOz98R4MuW1//5LYjzMq/54n1I9S3V36q+E8Xxh/TzSPHepjpI9Wd8LpgPHq8fCuCsw/zEUZf5BiEH+hgEvcbRt9dHBvbXzcLdo/oedM/H/joofcPEdwf46e9m8Hj9YABnHeYnLmmu9GOdw5AX/Y6EL77n5gn3CPRaf/G/C9U/GnPpZx76vd6vIDPOc81LXNIcqX8Y9HKfzBXudtUl0DMP++QnzRsivuvAT91zweP1n6LMOOsYEsAlzYt+rHMIcPQ7Gr6Y103C3a36EXTPRV4/Sv+V4rsbOujvJvB4/ccAzjrMT1zSXOljCPQaR99evzKQ1xzh3lZdDt03Ia/90rVQfA+Dn/7mgMfr+wM46zA/cUlzpY8rodc4+vb6wkBeNwp3i9/H0D0Hef0gXReIbwn46e9G8Hj9hwDOOsxPXNJc6cc6L0Be9LsQvnhvz/bnf+i1fuP2Sc90zKWf2ej3+r4AznPNS1zSHKnfuOkB37OEexo6ZsP3Xs2ZDD7qnIV+r+8N4DzXvMQlzYf6jZscOB8zhVuk+gb0WJ/xezRvqPhuAT91zwSP1/cEcNZhfuKS5kU/1jkU54N+J8MX85rhe0f1c+ieiby6iWeU6v3QQX8zwOP1bgWZcdZhfuKS5kofQ6HXOPq+H/6Y1w3CPaW6DLpnIK9d0jVJfA+Bn/5uAI/Xd0WZcdYxKYBLmit9jIJe4+jb657Pe2i6cM9Br/Ubt1O6p4GPfqaj3+s7AzjPNS9xSXOkfuOmBfbJ9cL9TvVj6JmOffK95g0W3z3gp+7rweP17wM46zA/cUnzoh/rHIx9Qr/T4It5TRPuQdVPoft65LVDukaI7z7ooL9p4PH6jgDOOsxPXNJc6WMw9BpH314fEThXU4VbDL3Wb9x26RkLPvqZin6vbw/gPNe8xCXNkfqNGxvYJ1OEe1J1M/RMxT75TvMmiO8Z8FP3FPB4/bsAzjrMT1zSvOhjLPQaR99enxDIa7JwL6quge4pyGubdM0S3+Pgp7/J4PH6tgDOOsxPXNJc6WMC9BpH316fFThXk4T7C/Rav3FF6p8IPvqZhH6vFxVkxnmueYlLmiP1z4Je7pOJ3k+qW6BnEvbJVs2bIr5nwU/dE8Hj9a1RZpx1TAngkuZFHxOht/j7Zvj2+pTAPpkg3F3QOxH75Bvpvhx89DMB/V7/JoDzXPMSlzRH6jfu8sA+GS/cA6qboGcC9skWzRsuvqfBT93jweP1LQGcdZifuKR50cfl0GscfXt9eCCv64R7SfVN6B6PvDZL12zx3Qp++rsOPF7fHMBZh/mJS5orfQyHXuPo2+ueb9+lVMdBp3V7vQ36qX8c+rzepiAzjnkQly033gv+O9jZfo/7fEGn/y52QLW1eDcBR74D+Dsfcdn+/kZdnnsAOOo2n/H0/bTWX1Pfq6rO2biNws0Xz7xA7uZzv9c3Rplxnjs/gKOeNphvHPV7fX5gv7YX7jfI1esp9bVSbY157DcuBZx5jU8F+KijNebz///hZ/3iVL8noziP552Zive9rf2yU3V9lFn/j9hXnOf+t4HzPOO9Tj7qto6dwNGHeZhz0ufBnIzzfP26+H3wlH5/nxZeUV2vulLV+8/72v0b9PNVmjNX9UnVR7FPuf8937xe3xDAWafnEZf03NGvdV+FPJnHk/BpHHOaD//GMddHkRfP8ZhUXK9z8HpL6GYeY9Dn9ZYFmXHMl7hsz4H3r89BI9XROBfF37Np3+9XbYF9G+Lbj/Oe6/mjLs/dDxx1m894+n5S66+r72VV52zcOuEWiGdOIHfzud/r66LMOM9dEMBRT0vMN476vb4gsF9PF+5a5Or1fcq1ufpbYB77jdsXeB7G78O+MY46vG5efi6uJ1wT1VHQ43nF349q7s+qzcBP3e73HPcTRx3m/z7Aly0v+rHOn4GjX/M1C+RV2vtHdSTmNEFeH2veMeIrBD/1uN9zPk5nxlGH+T/OMwf6sc5jsL/otxl8Ma+0cN1Vr8GclshrmXRVEl9T8FOP+z1nWTozjjrMvyzPHOjHOisBR7+F8MV79DThRoDf84zbLd3ngo/z3Wfe3enMOM41727kk9Q39RtnXn7+PaxfnCz8cOixPn+gc9970vedahPMsf734cM8nvteAEddnvMecNRnHuZHf9b7XYAv2/NgTsY1Cewvz2+tejX0GFesRzyNwRviKx3wk9Q3dXluacyl7ibQyXuonPeh6p+jOI/nGv+5dP2qeg74qYf87vs84M/4z5GzcdTp+b/mmRf9GndOIK+SwnVWfTiK8zRFXh9IV0XxnQ1+6na/53yQzoyjDvN/EODLlhf9WGdF5EW/58AXz1VD8T4Uxfs741ztlZ6zwMf57jPv3nRmHOead2+evqnfuLOy+G6l+qcozkPfpcRzJnhDfKUCfpL6pi7PLYW51H0WdPJ8lBVvN9UHozhPK5yPz6TrBPE1Aj/1uN9zPktnxlGH+T/LMwf6sc4TgKPfM+GLeRWIt47qA1GcpxvyWi79W1XPAD/1kN99y5GD5xi/HM/FOOr0/K0Bvmx50a9xZwTySom3rur9UZynDvL6Qrq2q54Ofup2v+d8kc6Mow7zfxHgy5YX/VjnduDo13zG8x4yb6HqH6M4j3Gec1i1IXhDfIeRb65+qMtzDwNH3eZrGNgnx4m3l+p9UZynEPtkpeZVFV8D8FOP+z1nZTozjjrMvzLPHOjHOqviOdFvQ/hiXseLt63qvf5+L4rPNX6VdJUV32ngpx7yu29VwJ/xq/BcjKNOzy8LXNK86LcBfDGvKuJtoHpPFOdpi7zWycce1frkhx7yu28d8vIc49fhuRhHnZ6/J8CXLVf6Nc68vIc8v4Pq3VGcxzjrqSCeU8Eb4qsQ8JPUN3V5bgXMpe760Ml9cox4a6n+IYrzdMA++VC6tqjWAz/1kN99Hwb8Gf8hcjaOOj1/S5550a9x9QJ5lRJvb9W7ojhPLeT1kXRVE98p4Kdu93vOR+nMOOow/0cBvmx50Y91VkNe9FsPvphXNfGeq3pnFOfpjbw2SNcvqnXBTz3kd9+GgD/jN+C5GEednv9LnnnRr3Hm5T3k+R1VF0VxHuOsJy2ek8Eb4ksH/CT1TV2em8Zc6q4LndwnJ4l3oOpgzOmIfbJNuuqI7yTwU4/7PWdbOjOOOsy/Lc8c6Mc66wBHvyfDF/N6QrgX1Pe+qv8O5r+vFf/v2/XzDPHdqRr6u5v5zeP1tQGcdZifuKR/76Mf65yBvOh3AXwxryWa86g/h6Ti855AXmv8d0zxPQEd9Gf+J5DTmgDOOsxPXNJc6cc6xyAv+p0BX8zrcd/zwn+Zis9bgrxW6+crxPcgdNCf+Zcgp9UBnHWYn7ikudKPdV6BvOh3DHzx3l6sOc/6fZuK6zdulX6eirn0Y77HkcuqAM5zzUtc0hyp3zjz8u8/j6l/qfCfqK5Oxfms030r9fMi8d6ruhjz6MPzFiOPlQGcdXkOcUnzo5+p0Gscc7CvRcAxp8XIgfvrUem5NRWf8xh0rtDPF2IufZvvMeS3IoDzXPMSlzRv6jfOvLyHHlH/8/73tup/ARtONDh4nJ2ca7BW5XmGMSQc1LAB007+aJIWkM7U1ESxJtImGjSxiUbHVk4bMCAolDExzLRVREajIihpRNNRDuoE8JA6owgoJ9FUFBHDSYMCWm1m2tpUAUnHqLRDZ8p9rZl94du1WP65x1nX89z387K+j29/z2bN7d3t//5b0nFYP3VYur2W/5/x6cO6NDo8uivXPxl+cUfXPlx/rcAt7921vzn6zO39//vu6f3xHHnh8IPnOv49wzH/xHCrov/Su2ufxTqvV/P/N6bfP6q/55uoPlx/tcCRg/7mmp6r55ihvHCem+s3Fs7r8nAro88rN3PA70yumen3E/X3fJerD9d3Fjhy0N9c03P1POScqfPyvDdqrh7duvITwv1YeckP96vkGSFfzzNB9Vz/VYHDl77mmp6j88ONKNwn48PNi76mPBN0n7wSv870+5n6O/d49eH6KwWOHPQ31/S8PMcI5YXz3FzvLJzX98I9HN2o3ON1Xi8n17T0u0P9Pd/31IfrLxc4ctDfXNNz9Rydygvnubk+rfC6uozXqfKSH25H8oxSP89zmeq5vqPA4Utfc03P0fnhRhXuk3HhFpBTeS7TfbI9fhPTb5H6O/c49eH69gJHDvqba3penmOU8sJ5bq5PLJzX2HDLeJ9Q7nE6r23JNT397lN/zzdWfbi+rcCRg/7mmp6r55iovHCem+vTC6+rMeGeUV7yw21Nnjnq53nGqJ7rWwscvvQ11/QcnR9uTuE+6Qy3MPoL5Rmj+2RL/Cal323q79yd6sP1LQWOHPQ31/S8PA85J+k+8bxzNJfPa3S4e6K7lLtT5/XL5JqQfouVw/ONVh+u/7LAkYP+5pqeq+ch5wSdl+edpLl8XqPCPRh9SblH67xeSq6r0+8flMPzjVIfrr9U4MhBf3NNz9VzTFBeOM/Ndfz9PjSSz03KS364zckzVf08z0jVc31zgcOXvuaanqPzw00t3Ccjwt0V3aw8I3WfvBi/sen3U/V37hHqw/UXCxw56G+u6Xl5HnKO1X3ieadqLp/X8HBLo79W7hE6r03J9f30e0Q5PN9w9eH6pgJHDvqba3qunmOs8sJ5bq5/v/C6ujTc3ysv+eFeSJ6R6ud5LlU9118ocPjS11zTc3R+uJGF+2Re6u/jc5ryXKr7ZGP4yem3QP2dm/704frGAkcO+ptrel6eY6TywnluruPP3N2jV4dbF32qd9frZ6Xulugs+VFHH/NwTxW4Uj/4WerXK1wP8euju6PvRveqH3X0uzW6JPpkdFXLfHDrda72g3O+WfKH2605ndsc8z9Z4Hw+qzS/X1fwv3/sYT05OvjYrn3g6fNW9L3ogcJ8dXnMkeOtAudcq+QP53neU244z3tAc/n9F/7M6FdUD0f9J/oc1u59Pj5nnX/Jl77mnId++MM5P9fp6/sE/mvR86LfVB94+vSO9o3203k0zWOOHL0LnHN1lz+c5+mr3HCet5/m8n0C3xkdo3o46gdFTy7krPMv+Q4qcM7TT/7Vz13Kf7Lyem74KdG/Vj0c9adHh7T0L/meXuCc52T5wzn/EOX16wP+h9FroteqDzx9hka/ER3WMo85cgwtcM41RP5wnucbyg3neYdpLt8n8DdHb1E9HPXfjV5UyFnnX/L9boFznmHyh3P+i5TXn2vgZ0fnRu+M3qV+1NHvkujw6Jjo2Jb5zJHrkgLnfBfJH87zDVd+OM8/RvPB+XzGan7fX/D3Ru9TffU+mPoro5ML89T5l3yvLHDOM1b+cM4/WXl9f8E/EH04+nh0ufpRR78fRKdFr4vOaJnPHLl+UOCcb7L84TzfNOWH8/zXaT44n88Mze/7C/6Z6C9UD0f9nOhthXnq/Eu+cwqc88yQf/U9u/Lfpry+v+BfiG6Kbo/uUD/q6Dcvemd0QXRhy3zmyDWvwDnfbfKvvj/RfHcqP5znX6D5qp/zdT4LNb/vL/jXo2+oHo76B6IPFuap8y/5PlDgnGeh/OGc/0Hl9eco+Dejb0f/Q33g6fNw9PHo8pZ5zJHj4QLnXA/KH87zPK7ccJ53uebyfQK/P/qe6qv3jdSvia4t5KzzL/muKXDOs1z+cM6/Vnk9N/zB6H+rHo7656LPt/Qv+T5X4JxnrfzhnP955fXc8D2OO6w9j+taD0f9tuj2lv4l320Fznmelz+c829XXs8N3y/aX/Vw1O+Jvt7Sv+S7p8A5z3b5wzn/68rrueEHRAeqHo76vdF9Lf1LvnsLnPO8Ln8459+nvJ4b/ovRP1F99T1r6j+IftjSv+T7QYFznn3yh3P+D5XXf//BD4meFR2qPvD0ORT9VPYLPTra5TFHjkMFzrno10N7Ds9DzkPq53npU83V7eP5YdFzVQ9HfZ9oh86pqX/Jt0+Bc54e8odz/g7l9X0C/xfRv4peqj7w9PlM9HPRz7fMY44cnylwztUhfzjP8znlhvO8n9dcpX0Y+5gnC/sw9jQ36Hv1q1XH9bPENd2HOccN4vzn/ZT2KPuiz6oPvPdNq6NzC/PV5anebxvutZ5UvpKv55irvPaFXy1fnxc8e5A/in6kPvDeI/02uqFlHrim+yrnWi1/OM+xQXntC/9b+fq84NmXfDX6JfWBP2KvFD3YMg9c0/2Vc9HvoPp5juq6+nlurncvfD6BZ3/yLdd361rPfqW/zqupP1zTvdYReeyvfvD91c/3CTz7k7HRC9UH3nulwdHPtsxTfW+r8y/tr5yrv/zhPMdnlde+8IPl6/OCZ88yNTpBfeC9jzojekrLPHBN917ONVj+cJ7jFOW1L/wZ8vXrCp69y3TVV58nU89e5tyW/nBN92HOc4b83Q/+XPXz96rw7FVmRW+IXqd+1HkvdXH029HzWuaDa7oHc75z5Q/nec5TXjjP/23N53zwFyuf7y949i4/VT2c91rjWvrDNd2bOc/F8nc/+HHq5/chePYq90fvVp/q312kD/uXKdHxLfPANd17Odc4+cN5jvHKa1/4KfL1fQLP/mSF6uG8n7q+pT9c0/2X80yRv/vBX69+vk/g2Y/8U3Sl+sB7r3R7dGbLPHBN91fOdb384TzHTOW1L/zt8vV5wbMHeTm6UX3gvW9aFL2jZR64pnst57pd/nCe4w7ltS/8Ivn6vODZl/xzdKf6wHuv9FD0/pZ54Jrur5xrkfzhPMf9ymtf+Ifk6/OCZ3/ym+i/qg+8908roo+2zAPXdM/lXA/JH85zPKq89oVfIV+/b8Ozdzmg+up9KPXsZda19IdruudynhXydz/4dern+wSevcv/RN9XH3jvozZGn2mZB67p3su51skfznM8o7z2hd8oX58XPPuaXnzPrT7w3mPtiG5qmQeu6b7MuTbKH85zbFJe+8LvkK/PC549zwnR49Wn+nfL6cM+6I3ozpZ54Jru2Zxrh/zhPMdO5bUv/Bvy9XnBsx8aFD1Jfarfe0gf9kj7o2+3zAPXdD/nXG/IH85zvK289oXfL1+/b8OzRzpV9dX3xalnz/RRS3+4pns859kvf/eD/0j9fJ/Asx/6s+iX1Afe+7We0YMt88A13eM5F/0Oqp/n4HpP9fPcPbWX83nBs0c6L/rn6gPvfVvfaC+dX9M8R7vXc66e8ofzHL2U177wfeXr84JnTzY8er76wHsv94XoCS3zwDXd/zlXX/nDeY4TlNe+8F+Qr/eEV7F/ia7RnvDM7A9+FL1J+wbq6GMebk2BK/WDv0n9/D0i/NP8e9fob6L/qX7U0W929K7oiujKlvngnta52g/O+W6SP9yLmtO5zTH/igLn81mp+f26gu+Vz1kDogOP7doHnj47onuj+wrz1eUxR44dBc65Vsq/+vyoefYqN5zn3ae5jvh9nnBDomeoHo76Q9Fu/L19lP4l30MFznn2yb/aOyg/1w8V7hP4odFh0XPVB54+PdK3T7SjT7s85sjRo8A5Vzf5V39Pah5y9hDneTs01xG/1xLukuio6Gj1qX6vJX1OjA6IDizkrstjjhwnFjjn6pA/nOcZoNxwnneg5jriuSThJkWvjE5WH3j6nBr9cvS0Qu66PObIcWqBc66B8ofzPF9WbjjPe5rm8vsQ/N9E/1b1cNR/PXp2IWedf8n36wXOeU6TP5zzn628vk/gZ0ZvjP5IfeDpc370O9ELWuYxR47zC5xznS1/OM/zHeWG87wXaC6fF/yPoz+J3qE+8PQZER0VHV3IXZfHHDlGFDjnukD+cJ5nlHLDed7RmsuvK/gF0YWqr94nUj8xOqmQs86/5DuxwDnPaPnDOf8k5fV9Av+z6KPRx9Snel5t+kyNXhO9tmUec+SYWuCca5L84TzPNcoN53mv1Vw+L/h10aei69UHnj63RGdFby3krstjjhy3FDjnulb+cJ5nlnLDed5bNZdfV/BboltVD0f93dF7Cjnr/Eu+dxc457lV/nDOf4/y+j6BfyW6K7pbfeDpc290cXRJyzzmyHFvgXOue+QP53kWKzec512iuXxe8L+O/lv039UHnj6PRB+LLivkrstjjhyPFDjnWiJ/OM/zmHLDed5lmsuvK/i90X2qr94vU78qurqQs86/5LuqwDnPMvlXPy8r/2rlPeL3osP9V/TD6EfqU/1edPqsjz4b3dAyjzlyrC9wzrVa/nCe51nlhvO8GzSXzwv+GPYQfF/K9986L/psjm6Jbi3krstjjhybC5xzbZA/nOfZotxwnner5vJ5wX+a73n5Hld9qvf59Hk1uiu6u5C7Lo85crxa4Jxrq/zhPM8u5YbzvLs1l9+H4P8g+oeqr95XU/9O9N1Czjr/ku87Bc55dssfzvnfVV7fJ/CDo38cPUV94OlzIPp+9Hct85gjx4EC51zvyh/O87yv3HCe93eay/cJ/JnRr6gejvpPZL/RvePjc9b5l3zpa8556Ndd+xjn5zp9PTf82dFzVA9H/XHR4zV/U/+S73EFznm6yx/O+Y9XXr8+4L8VvST6l+oDT5/+0ROjJ7XMY44c/Quccx0vfzjPc6JyV9+Xat6TNJfvk6u0N1obna/nonrPdnP0cn0PfpXquX6muKZ7vPnKVfJ1/pvVz/fJGu2J3om+pT7w3qc9Ef25zqNpHrime7u1ylfy9Rw/V177wj8hX58XPHueQdHfO7ZrH3jvyfZH32yZB67pPs65npA/nOd4U3ntC79fvkf8Xk449kF/qvrq5xXty47p084fruk+znnod4w45+d6t8LnE3j2OjxX8WvqA+89mZ8jebR54Jru45zrGPmbq3vepefuK1/fJ/DsdTpVX33uTD17n9LzKev84Zru35o+F9P5B6mf54ZnXzNF9dV9n3r2OaXnU9b5wzXdozV9Lqbzn65+fn3As5/5u+gP1Qfee6xzoqXnU9blgWu6L2v6XEzPMVR57Qt/jnx9n8Czn7lJ9dXnrdSzv7mwpT9c0z2a85wjf/eDv1D9/PtI8Oxd5kV57uNs9aPO+6vOqJ8jebT54Jruy5zvQvmbq3vepecfrvmcD75T+Xx/wbPXWaT66v0l9ex9rmjpD9d0r+Y8nfJ3P/gr1M/3Fzz7mWVRnvv4gPpR573X9KifI3m0+arvjfXnUdqzOd8V8jdX97xLzz9N8zkf/HTl8/0Fz57nadXDeT82u6U/XNP9m/NMl7/7wc9WP99f8Ox1tkV57uML6ked92Dzo36O5NHmg2u6d3O+2fI3V/e8S89/p+ZzPvj5yuf7C5590B7Vw3mvtrSlP1zTvZ3zzJe/+8EvVT9/joJnz8NzFd9UH3jvyfwcyaPNA9d0H+dcS+Vvru55l577cfn6PoFnH7Rf9dX7YOrZF5WeT1nnX/18qz+n0j6u6XMxnX+N+nluePY6B1UP5/1Y6fmUdf5wTfdvTZ+L6fzPqZ/nrvZr/DsL/j2J5vaeq/R8yjp/uKZ7tKbPxXT+bernueHZu/RTffU+l3r2MqXnU9b5wzXdhzV9Lqbz71E/zw3PnmWA6qv3tdSzhyk9n7LOH67pnqvpczGdf6/6eW549idfVD2c906l51PW+cM13Ws1fS6m83+gfv77D579yVejQ9QH/oi9kp4j6edT1uWBa7q/avpcTM9RPedS/Tz3J7W34j75X1BPKdx4nJ2dWaxW5RWGTbQyyKm2mjQRpMZSBQcE2sZoUhG4MHVKS2kvWhlFnBgVUXFAkNlZmcRqRQWnVtEqs4oVsIOK2sYqUFITFdMqoqBYcOgF6/mT8+Dq/s7uzZvAs9b7rt3975+zV8/X/fbZ858TD9ijvUP7hJ4Uul9w+x64R9uFNoXud2Bz7kTXH9i8Hg4/ePeH2yuP/dUPvkn9WgX3DfH9Qn8Repr6wNOnY+h3Qw+pmQeun66/feCcq0n+5pjHOe1rDt/992nOz48L+FDow6F3tmrODY1+l4SODT1X9xN19B2acPal71BxznOu/OGcf6zyem74J0OfUj0c9deETqjpn/lek3DOM1b+cM4/QXk9N/wzoc+qHo766aEzavpnvtMTznkmyB/O+Wcor+eGfzH0JdXDUT8ndG5N/8x3TsI5zwz5wzn/XOX13PCbQv+pejjqF4U+UNM/812UcM4zV/5wzv+A8npu+C2h76kejvrHQ5+o6Z/5Pp5wzvOA/OGc/wnl9dzw20I/Uj0c9StCV9b0z3xXJJzzPCF/OOdfqbyeG3536Oeqh6N+bei6mv6Z79qEc56V8odz/nXK67nh92+9R1u1bl4PR/0roa/W9M98X0k451knfzjnf1V5PTf8QaHfUj0c9RtCN9b0z3w3JJzzvCp/OOffqLyeG75D6GGqh6P+3dAtNf0z33cTznk2yh/O+bcor+eG7xzaRfVw1H8cur2mf+b7ccI5zxb5wzn/duX13PA9Qn+gejjqPw/9oqZ/5vt5wjnPdvnDOf8Xyuu54XuF9lZ947ka9Qe026Pt2tXzz3zpa8556Ic/nPPz9/T13PB9Q3+uejjqO4QepvlL/TPfDgnnPO3kD+f8hymv54bvHzpA9Y3PY9QfFdq5pn/me1TCOc9h8odz/s7K67nhh4Wep3o46ruFdq/pn/l2Szjn6Sx/OOfvrryeG35c6GWqh6P+lNBeNf0z31MSznm6yx/O+Xspr+eGnxR6nerhqD8j9Mya/pnvGQnnPL3kD+f8Zyqv38vBTw+dHTpHfeDp0zd0YOigmnnMkaNvwjnXmfJvvC/QPAOVG87zDtJcvk/gF4YuUj0c9aNCRyc5q/wz31EJ5zyD5A/n/KOVN/64MT/84tCnQp8JfVb9qKPf+NAJodNDZ9TMZ45c4xPO+UbLH87zTVD+xntAzT9d8zXeM+n6zND8e70PC25r6Ieqb9zfUb8sdHkyT5V/5rss4ZxnhvzhnH+58vr+gt8Vujv02DZ79Lg2zftRR781oWtDPw3dWTOfOXKtSTjnWy5/OM+3VvnhmNvcpwmH/05xvr/ge4aOVj0c9W2a9uhJTV8/T5U/HH7w7g/nPPQ7KeHo65z+nmNPwXv7R0IXhv6mVXPe+4xLQ0eFDtPPHdR7H2KudG/iXMPkD+c5RimvfeEvla+vFzzv+5eEPqY+8N6DXBt6Rc08jeds4b7FuS6VP5znuEJ57Qt/rXz9uYJnT7Ba9XDem8ys6d/4XivcyzjPtfJ3P/iZ6uf7BJ49wcu8b1UfeO9P5oXeXDMPXOmexrlmyh/Oc9ysvPaFnydfXy949gubQ99QH3jvXR4MvbdmHrjS/Y5zzZM/nOe4V3ntC/+gfP25gmcv8bbq4bynebSmP1zpHsh5HpS/+8E/qn6eG569xMeqh/OeZlVNf7jSPZDzPCp/94NfpX7+fMCzl/gi9FP1gfe+5oXQ1TXzNN5fFu6FnGuV/OE8x2rltS/8C/L19YJnn9E6dN/WzfvAe8/zWuhLNfPAle6TnOsF+cN5jpeU177wr8nXnyt49iDfVj2c90KbavrDle6dnOc1+bsf/Cb1830Czx6kY+gh6gPv/dB7oZtr5oEr3UM51yb5w3mOzcprX/j35OvrBc/+5OjQTuoD773SjtCtNfPAle6vnOs9+cN5jq3Ka1/4HfL15wqevcsPVQ/nPdSXNf3hSvdczrND/u4H/6X6+T6BZ+/SJ/RH6gPvfVRT6Fc188CV7r2ci35fqZ/n4O+b1M9z8/f4+nrBs6/pF/oT9Wn870CjD3udjqEH6/qV5oEr3Zc5V5P84TzHwcprX/iO8vX1gmfPMzD0V+rTeG5FH/ZBXUI71cwDV7pnc66O8m+8H9ccnZTXvvBd5OvnEDz7ofNVD+d9WY+a/nCl+zjn6SJ/94PvoX6+T+DZD10eOkJ94L036x16Qs08cKX7OefqIX84z3GC8toXvrd8fb3g2SNNDr1afeC9bzsr9NSaeeBK93rO1Vv+cJ7jVOW1L/xZ8vXnCp690lzVw3kfN7imP1zpvs95zpK/+8EPVj/fJ/DsjR4Ina8+8N63jQkdWjMPXOlez7kGy7/xvkRzDFVe+8KPka+vFzz7odWhD6kPvPdwM0MvqZmn8d5Q/71l+z7nGiP/xvtTzXGJ8toXfqZ893p/Ghx7o22hb6lP4/1p9GG/tCL0kZp54Er3es41U/5wnuMR5bUv/Ar5xh83nkfw7Ie6hh4Rekib5v2o8z7us9D3QzfXzAdXuv9zvhXyN8dczgl3hK6D53I+c+Tj/tpX/GjV8ffey33WQj+40n1fV+Wxrz9X8+IPFvH+lvezoXfovdiQ+PlmdOiY0ItDz9HPR9TjMyThnIP+Q8Q51znybzz/NM8Y5W483zXvxZrL1wt+Me99Q/+gPvD0GR96VejVSe6qPObIMT7hnOti+cN5nquUu/EeXfNerbn87yH4VaFPqx6O+qmh05KcVf6Z79SEc56r5Q/n/NOU1/cJ/LrQv4T+VX3g6XNL6KzQ2TXzmCPHLQnnXNPkD+d5Zik3nOedrbl8veDXh24I3ag+8PS5I/T+0IVJ7qo85shxR8I512z5w3me+5UbzvMu1Fz+XMG/E/qu6uGofyx0cZKzyj/zfSzhnGeh/OGcf7Hy+j6B/3fo1tAP1QeePk+GLgtdXjOPOXI8mXDOtVj+cJ5nmXLDed7lmsvXC35n6H9Dd6kPPH2eC30+dE2SuyqPOXI8l3DOtVz+cJ7neeWG87xrNJc/V/D78fNE6+b1cNS/HLo+yVnln/m+nHDOs0b+cM6/Xnl9n8C3C/1m6IHqA0+f10PfCH2zZh5z5Hg94ZxrvfzhPM8byg3ned/UXL5e8N8JPTS0va/bPs37vBX6dug7Se6qPObI8VbCOdeb8ofzPG8rN5znfUdz+XMFf2ToUaqHo35b6EdJzir/zHdbwjnPO/KHc/6PlNf3Cfxxod1Cu6sPPH12hu4K3V0zjzly7Ew45/pI/o2fWzXPLuWG87y7NZevF/yPQ3uGnqI+8I0+8fNtm9C27b4+d1Uec+Sgvznnol9b/fzuecjZSpznbau5/LmC/2noz1QPR/2hoe11nUr9M99DE8552sofzvnbK6/vE/hfhv469Gz1gafP4aHfDz2yZh5z5Dg84ZyrvfzhPM/3lRvO8x6puXy94IeEDg09V33g6XNsaNfQ45PcVXnMkePYhHOuI+UP53m6Kjec5z1ec/lzBT829FLVN963Rf3JoT2TnFX+me/JCec8x8sfzvl7Kq/vE/grQq8Nnag+8PTpE3pa6Ok185gjR5+Ec66e8ofzPKcpN5znPV1z+XrBzwy9LfR29YGnT7/Qs0P7J7mr8pgjR7+Ec67T5Q/nec5WbjjP219z+XrBLwi9N/Q+9YGnz0Whw0NHJLmr8pgjx0UJ51z95Q/neYYrN5znHaG5/ByCXxm6SvVw1E8JnZrkrPLPfKcknPOMkD+c809VXt8n8BtD/xP6vvrA02dh6FOhS2rmMUeOhQnnXFPl33hvqHmeUm44z7tEc/l6wX8v9j5dQo9mL6brRZ8PQreH7khyV+UxR44PEs65lsgfjjncb3vC0XeHOO/t4Eeojr+n7oSm/58r84Nz/x3qa46+9vdzgf0Xex3O5Zuv91Tej2XnFFLnvZq50v1b6fmIzn+J+nluePY1T6oeznuu7JzCKn+40j1a6fmIzn+N+nluePYzz6gezvur7JzCKn+40v1Y6fmIzj9d/Tw3PHuWF1UP531Vdk5hlT9c6T6s9HxE55+jfp4bnv3JJtXDee+UnVNY5d/4firca5Wej+j8i9TPc8OzL9miejjvk7JzCqv84Ur3VaXnIzr/4+rnueHZe2xTPZz3R9k5hVX+cKX7qdLzEZ1/hfp5bnj2GbtVD+c9UHZOYZU/XOmeqfR8ROdfq36eG579Befy7dbc3u9k5xRW+cOV7o9Kz0d0/lfUz3PDs4c4SPVw3udk5xRW+cOV7otKz0d0/g3q57nh2S90UD2c9zLZOYVV/nCle5/S8xGd/13189zw7BM6qx7O+5bsnMIqf7jSfU7p+YjO/7H6eW549gI9VA/n/Up2TmGVP1zp/qb0fETn/1z9PDc87/t7qb7xfIl69gHZOYVV/nCle5jS8xGdH45+nhue9/t9VQ/n/Ud2TmGVP1zpfqX0fETn76B+nhue9/T9Vd/43EY97/Gzcwqr/OFK9yml5yM6/1Hq57nhef8+TPVw3ltk5xRW+cOV7kVKz0d0/m7q57nhed8+TvVw3kdk5xRW+cOV7jtKz0d0/lPUz3PD8958kurhvH/Izims8ocr3W+Uno/o/Geon98rwvP+e1bodPWB9z5hQGh2TmFVHrjSvUXp+Yieo6/y2hd+gHx9n8DzPvx+1Tc+n3o/P7KmP1zpnsJ5Bsjf/eBHql/8cWN+eN5/Px3K+X+L1Y867wumhfo8wZbmgyvdTzjfSPmbqzr30PNP0HzOBz9N+Xx/wfPe/APVw3n/sLSmP1zpfsN5psnf/eCXql+8Bm88j+B5j35MaCed/7dLfan3fuGT0K2hPl+wpXnhSvcazrlU/uaqzkHk77kenguuk66fr4PnMMcc3qccrX3KMdqneO/xSQv94Er3Kccoj339PTcr/uBvoX8PXcl70FbN+QHx88JdoXeHTgkdqJ8nqMdnQMI5B/0HiHOugfKH8xxTlBfOc9+t+fx5nK2+/wp9NXRZ6P28b27VvN55Hw69M3RS6MjQQco7J5nfXOl1cs5B8ofzXCOVF87XYZLmcz6u38NJPl/fO3XdfD/PUc7fh94XOlf3s+e9LHRE6GDlmZtcL3Ol19W5BssfznOMUF77wl8mX3+vzlVffn+Q30uEc67s9xTnJfOYK5279PcjnX+0+nluzk3lXNR7ee5obp+rOjz0PPlT5/NYzZWe2+o858nf/eCHq58/H3eJ/13oozz/9Pmw77jQy0PPV567k9zmSudzrvPl737MMy7p53kv11y+Xr9lTxL6Suhzoffoel0Qfa4LnR96feiFykM9PhcknHPQ/wJxznWh/OE8z3zlhvO812suX697xL8e+o/QBbpezndP6ILQi5RnQTKfudLr4FwXyd/9mOeepN9e82ou//zIfcvnmPOJOX/4cd3X1Plz7vOMr9R9Xfq8aOnnqfR86dLzlz3vOM3jfvBXqt9eP6fre3FpKL//ze+VL9J19vfsxFD/3rl/v77q+6il3+st/b3+qt+P93WYmPj6Oo3XdfC/j3lO83xdEfqn0D/rOcZzjXo/3yeH3hZ6u55Tfv7Rz98X5kq/V0qfu553ctLP81+nueB83W7T9YDzdb1d18ufA/59yL/PXwj9o+4H7g/q/O/9W0Nv0P3Q0n+PtvTni9L71vNMVF77ch1uTXx9nW7QdfD3IM8vnk/P6/7gfoH3c+5G/fft+6jq3zEtfZ6W3r+e58akn+edrLn83OB5zvnznL/O+epr5EsO6n1Ov89tv0n+Lf0+gSv9/wcovU6l5+6Xnkvv63Sj5nc/+JvUz88Nnv98nvgccC4G521w/gh1/r7gc+PzOHw+Sem5LFXfT3Cl56KUPjdKzxfxdbpF/bjO/wMS9EmqeJydm3v01/MdxyOqjW3WWNg5c51zFm07k7u2c0aW3TCK2Nkll7nsSqgpLBlTKhUq3WVKRVQ0EZVVKmwIM9ewEbWbCmfYH54P53jsvPd9f/jn6fR9fl7v1/P5eb9f79fn/fn82rV5778727+HS4P3BR8OPhtcEWyX6wZv8x5eGRwWHB+cERwZ3KrNB8dhXMeBd6fGJc5g8e5T/s7HPHSNL/Csd6T0wLM/M6T/I+Hl5zZL8j/Lg2uCfw4+FFwZXNb+g9cPTdyrgpOC1wfHBkcHRyjfJYrL70PFIz/4HhfeMuVbGtd6JxXirZQP1gPPfo2VD/Ds7/XyDV+3DjI//hB8MPiE5g185s3w4JjgVM0D8iEu4/j6pvP0QeXrPOA9IT3O0zyPO7Xg14L8w5+Cz+s+L5dfgxLnuuBM3Q/PhwWKw++DxGN8+B6n6Ty0npmFeNY7SbrsF/WEerE2uD54v/xy3ZkVvCM4SvmsUBx+d/2trW/Oa5TGdzz0zCrEs947pKtDeOwvrG/W7yvBdcGXgk9qX3I9mBucF7wlOO1D1pWHNC5xxhbikffcQrwnpaeU30vSbz3w7NM8+eB9ifXO+n8m+GLwVd1f7jfXu05MD94cnK/77HnRqu7U7rfwnpEe5wXvRel13k3nt32aJf0eF/58jet1QH2h3rwW/LfmF/ON61yPbg/erfnQdN+srX9N14H13V6IZ91zpQuefbpbPngd/F71jjr1enCL3JiPBP+odXCJ6jL1bVFwVfCR4Djly7jk4Xjw+J3xiXOJeLX123rGKU/Hw49FhXj2a5V8gGc/H5FP3j9ZN/8Kbgpu1HqCz3q6K3hv8J4PuS7hMT58jwPPec3X+PA2SZfzNY+494jnukEf81zwheC7WmesO66jz7kpODt4v9aP1yXjMK7jNO2vnPfsQrzaumH990sfPPtzu/Tb57W6z9yfd7Re1stn7w/czxVaL15ftftMq36r6TytXf/WvUi6PC78FRrXPlPvqedvBDcHN6jv4TrvD0uCi4MLgvOUX6s+qul+tE55lsbdIF3O0+Piw5LCuPZpsXywz4u1v1CfPxfcLfiYfB6ifY16/vfgq8HJyo9xGNdx4PE74xJniHi1+5l1TFaejof+vxfi2Z9Xpd/9xsL8z6PBL+S6g4N7B6lb1EOuvzRxJwbfIJ9t38ONqm+um4xLHo4Hb6HGJ86lhXjoeKMQr7auWz+8jeLZr43yAZ795Xfy9Dqg/rMfQPgo+lSPuM77xcrgo1p3TfvV2v2paX2wniXK1+Piw8rCuPbpUflgn9kH6G/eDrYNccvgO/LZ/c/y4APB1YV9p1UfVbs/wXtb+TsfeOiB73zhWe8K6XE8+KsVz/Vms+YD92eb4Lasi+CbqjfeN7iva4KPBR8MLm24D8Hjd8YnzmLxauctcdBVym8r+WA9Hhff1hTGta+PyS+vg9c137ivHwt+KshzE9e5v2IePB58OrhK+dX2abXPc7Xz1jpWKU/HQ//jhXj252npZ/7yXPhI/uHw8LsH2R/Yx+BPSJyPZ7/4hPYN72/EJw6/TyjwyIP45tXuq9YB7xPaB62b3xnf85L+iL7mG8FvB7/D/VF9dj+1feJ3Cu4YnCIdjEc8fnffWNu/OT/i7ShfrI98Hc/60bO94tmfHaXf9Zn5Tl3vEOxIPsEdtC643vX/4eBTwWeCz2p91O4nTddlB+lxXvA6Sq/zhmfdj0sPvO3lm/WbR9xnxfP9oQ+lz/xicBfuLwsn+K72T/evbwZfCa5Vn+S+qvb8orZvru3nrGul8oVnH9ZKHzz79or8sA74b0qH61Qbjb9T8NPar9m/uc56Xgg+p/3a+3urPrepf7V9hfWsUb7wrP856XN+8F9Qft4/t1HcTuxf6nfgO7/ng0+ob6ztm5r6sK3yK437celxnh7XPMb1vKReUWd2D+4R3FX9C9e5vr0WXB9cV+ibWvVDTeup83ta4zse+l4rxLPuddIFzz6tlw+el9Tzzwb3VD7kB586/3Jwg+KX9pXSfgGP8eF7nKZ+7Sldztc8x4P30fCYn1vovnI/9g9+PXhEkPMtzsOI4/6d+9kmfc4ng9sFS+dnrd4HNX1+qD23q53f9gd95tkvxt1O/aF9xqc24vk+bCdf3adQn6jn+wS7BPcK7qw6xvXeJzYFNwf/EXxR9by2Pjbdnzop39K41rupEG9n+WA98PaSb9YPz/5ulm/eD9hv6X8OCh6g/NHz/nsm9VNtc/+32Pb/6221vzft32p9tj7ydTzrJt4WWgf2id/bFtYBdZC62DnYNbhf8EDtM1zv+vl68J3gu8EtM37T/au2bsNznus1PrzO0u384XWVL9YHbz/5Zv3mkSd5vVtYB7tKD9cdEjxU9Zbr3C8wztbBdoU6Wtt31Nb52vthHW2Up+OhHz2OZ3/aSb99Zl2xbr4S7Bb8kuoX13kddgi2D76lfaG2HjZd912UZ2ncL0mX8/S4+NBBdRSefWpvH8Kjn6Te8bz6o+BRqoPw/dy7d+LupLrW9Lm5tu46T8Z3POffVnnCs15+37swL6kXhwWPDPbQOmBdcB315GOJ+6lgR60Dr5tW9Qke+cD3eE3Xq/VsrXzhHSk/rM884nYUzz4foPvH/Tkh2FPrgeu8v3I/dw/uovVQu083XYe18886OihPx0P/7oV49mcX6ff6P0T3pXfweNVr+J4HewR3K+wPrep+0/nmvNppfMdDzx6FeNa7m3R5XnbT/cLnXsGjg1/VvHQd5r7sGtyZfrBhPYfXTeMSp/2HnG9flZ5SfkdLv/V4XPMY133w/rrP3J8zgucEfxbkeZPr3a9wX/cNdgseqOfSpv1P7fNw7by1nk8qT8fDj30L8exXN/kAz34eKJ+8Dlhf1PXjgicGf6j1x3Wu+58N7hnsrPVXu380XffHKX/nA+9E6XO+8Kx3D+lxPPidFY9jKNYD7/c4l+E85VvBC4IXBgcEvxnkvR/x/H0X5zKfDnYP9ggeEdwh6PeFrb4fa/qesvYcyj6Qv3n2YXvpgWffdpB+ePa9u/yD5/vSQ/7C8307Qv573VFH2edPDvYJnqQ6y3XuA7oE9wl+TvtRbd2u7Tvg9VKepXGtr0sh3knSbz3w7NM+8sH7D/0WzwdnBn8Z/LnyI1+u93NE1+AhwYM0vnXV9nutnl+a+mm9XQvxrL+LdMGzb4fID3j29SD55XVAHf1B8PTgT4Nnqc5yHXX288EvBw8I7leo24zDuI5TW9/hna78nQ886+isPOH9VD5Yl3nE3U88+0yf0Vt5cP3Z6kO4zn208z600Ie06seb9j+1+3Ktz9a7r/Q4HvxDFc/1hrrEemId/CrYP9g3eIrqjesZ6+fw4GHBrwS/0LA+wuuj8Ymzj3i19eEU6SrlZz8OL8TrK7+sG559PUx++b0j36fx/dlPgkOCw4K/Cf4iyHfbxPH3bfsHewZPCB4dPJi8lX+r78Lh1X5f53y38viKh37ydzz701N64f2PX9IPz/4eLb/g+X6cIH/dX+8t3eQxNDgieKn2RfZJziOJ5+/40dMreGLwKO2DpXPMVt8Twav9e4La89Pa+VDbL9i/rvLB4+J/r8K4vi9HyV94vo8n6n54v6Nus0/2Cw4MXqS6/v65sPbRrwW/HjyysE+02o9r9xN4/ZS/84FnHYcqT3gD5YN1mUfcI8Wzz9Rz+r7hwauCl6nec537wt7Bk4LHqI7X9pdN9xnn3bsQzzoOV57wrPsY6YJnn06SD+4rztB95v78NjgmeGWQcyCud3/DfT022Cd4fLCb8q3tl2rPqWrnrfV0U56Ohx/HFuLZrz7yAZ79PF4++fy9v+YH9/+K4MUdPsh3n8I8OS74jYZ9Drz+Go84h4lXO58vlo5SftZ7nOK5blBnBgevDY7TfeS+ch116DvBHwVP0X0s1b9SXYNHPvA9XtP5dq10Om941n2sdJlHXOu3z/y9xcTgpODYIP1dd/nM32OcHjwjeLL6v6Z/32EeeZ1e4NX2qdazv/KFZ/0nSx88+3WG/PD65zxxfHB2cEKQc0T4nDOeFjw/+OOgzxdrzyudx2kFnvPqrvHhWc/5yhue9f5YuuwX57Ocl04PzgrOlF8+xz07eF7wXOVTew48s8ArxSPPswvxrOM85QvPOs+VHu//nJPzPon3O9cFb9Z9Zx5wvb/b5L3QqcF+uq+eL62+A216nl/7fqx2PtuPUwvx7Fc/+QDPfp4mn1xn2f/o524KTgmO1P7Ide4P+wbPCn5PfUHtftu0H71CeZbGtb6+hXgjpd964Nmns+SD6wbvf1ivrJ9bg/zd2/vf5SeO1/UFwU7Kp/Y9U+3f4dXWF+ffSXk6HvwLFI95Bf/b4t9GH9LhgzyPNyDov1Ns9XeFTfU4nx01vuPBH6B4Xo+X5x9GB6cF5wRvCF6t9fjdxPt+8GfBXwV/HvyB8mMcxnUceJdrXOJ8V7xpyt/5wLtaekr5zZEP1gXvBvlk3faZfpW+9MbgjOC84Bj57P72l8FzghcG+yi/2ue32n7a+fXR+PBulE7nDW+GfLAu8xj/QvG8/7O/8RzMc+nc4O+Dk7UPcr2/A+F5dmDwkuCZhf2w1XclTffh2ud66xxY4Fn3qdIDzz6dKf3w7Osl8sv7Es8dPFfcGbw9yHk2fD+fDA5eHOypfGrP4Wufg5xXT43veOgZXIhnvRdLl9/DcH7Mue+C4B+C9wVvCXJexnkdcXz+PCg4PDgs2D9YOt+rfb9de/5de65o/YMK8exDb+mCZ9/6ywd49nu4/IPn+zFM/no/4Nyf9ztLgsuCdwQ5z+c6vy8aGhwR/HWwl/Krfe9U+z7CeQ8txLOOXsoTnnX/Wrrg2acR8sH7wXDd59XBR4JLg/TX9O1c7/lzTXBC8Mpgqb9vdX7ddN7WPldYV1/l63Hx5ZrCuPbrSvkAz/5OkG9eB5yrcB7yYHBNcDn7vtaBz2HGBCcFrwr2UH6136nVnvs4vx4a3/HQN6YQz7qvki549mmSfPA6oD+gf6OfWhz8c/CP6iO43uf69GFDgtcHx2n/r31P0LSPqe1HrWeg8nQ8/BhSiGe/rpcP8OznOPnk+zNA84j7vyr4VHBFcLruj7+jZN5cHfxdcGTQ52ytvstser5Xuy6s52zl6Xj4cXUhnn0aKf3w7Ovv5JfrFP0H79XvDz4efEb9Cdf5Pf2o4JTg9EI/Ufu+v7Yvct6jCvGsY5DyhGf9U6QPnv2ZLv32mb6C71lWBp8IPqu+g+v8fczo4NTgDPUJ5Ff7nU1tv+O8RxfiWcdQ5QnP+qdKHzz7M0P67TPPMzyHPBR8UfkPk89+/hkbvFl5Nf1OqenzVq3P1je2EM+6R0sXPPt0s3ywz/S99LUPBF/Sehwhn90nXxu8Reus6fc/Tfvy2rphfdcW4ln3KOmCZ59ukQ/ePzkXp9+lT306+JfgQtaR9k+fp9Pf3hi8IXhp8CfKd4ri8vtZ4rU6x4c3VfmWxq3t8xfKB+txPHy7sRDPvt4gv7wOOMe7N/h8cK36LvowruOc74rgzOAs9V3u01qdG8IjH/ger2l/+Lx0Om941j1EuhwP/izFs8+cQ/E+/rHgy8GHg3fKZ7/fnxy8LTg+OFj51X4nUHs+5rwnF+JZx2DlCc+6x0sXPPt0m3ywz5yfcj76QvD14HPsD/LZ562zg4uCNwX7Kb/ac9va97bOe3YhnnX0U57wrPsm6YJnnxbJB58X833JP4P/0vxgvsDnu5OFwbt0H5t+v2IeeSws8Grnr3VMVr7wrPsu6fO85DmK5591wVeCT1JHNC/93DUvODc4LXie8qv9jqP2Oc/5nafxHQ998wrxrHuadMGzT3Plg+cl5zl8z/PX4MYg5zPw/Z3PnOA9wTHKp9V3Qk3PlZznnEI85z9GecKz3nuky/0Z34dQR6gT/w7+TfmRL9f7uxLqy93BWzW+ddV+n9Xqe5amftbWT/txd4Fnn+ZIPzz7eqv88nxmP+A93qPBzdon4Pt94MTgYtXzpu8Ta/cl5zmxEM86FitfeNY5W3pcZ/m+hDpFfdkU/BO+q876+zXq0b3B64L+/qPVd3DwWn330rTOWscFyhOedV8nXR4X/r0a1z7PZz0E1wffCm6gj5DPFyXeZcE7gvcFFwQvV36Mw7iOA2++xiXOReKtV/7OB94i6Snl95Z8sC54G+STdXv936r790bwzSDfE8H3PFgSXBps+l1S0/nmvAZofMdDz5JCPOtdKl32i/dmvO99h4mbjW+1/PL75RXBlcFrlE/t++na93fOc0UhnvO/Rnma53jwvP/z/oX3If8JdgzxbdVz6jvX+73NsuBTweWq602/U2n6vqh2/7HeZYV41j9RuuDhl+M9VYgH3z75/nBOyvM0z8ttQ/xMcMvgQ7o//o6F5+wHgi8FVwfHKt9W38U0Pc+tPR+wnrHK0/Hw44EW8fDLuuHxu+PBp5z8FwnTNBZ4nJ2dZ/iW5XnGwYGADJUhCA40iamxMZpYqCZm2LTRLE3rylTT7MQmqUnapkkaP4aNICCKqCBLFNCMuhmy995bGWpFAygI2A+cv/9x+DP38Txv/HIe//c+n/O6zut97ue51ystmh37748tj+GsYKtWx/DMYNvgwrS3yHW/bXMMBwSXB3cGVweHBk9o9s44xLUOPNqJi85vC3rkvbygZx9DlSc8fFtvZ0EPvn0nTFO9/pQPNgWb57oPB1sGn1ed74jeuOD84JHgsmB/5Uc89Gi/Qzzyge948Jxff8W3Hv7mF/Twbd6RQlz49u06z8gHy4Ntcl2v4AnBjapz3+jdG1wVPK7tMVyUv8cqP+IQ1zrwaCcuOn0LeuS9qqBnH+gtKvDwbz/waHdc+Pm42UnB2Ym7MnhWCO8NXhTsyvfb8p3XD4z+fcFdwVeDB4Pbg0OUL/HRpX2geOQH33HhOc8him89/O6q0KMO9gOPelnvVfEuUn1dJ/eDaflgW/DtYM9c3yG4Vv2gd/QeDs4NNs99sDF/P6j8iIce7b3FIx/4jgfP+aG3saCHv7kFPXybhy/HhW/frvN69Wv628XB84Ivqc5j9DyhP74VfCX4e/kgDnGtA4924qIzRry6zxF08FPK72I9Z+0L3nmqk337eTM98TcHTwnhI8Eeem/P0vOmT3THB9cFjwZf0jjG4wfio0t7H/HID77jNjpusd91Bb1WqoP9wKNe1jsqXg/V13VyP9iaD/YGO+a6j6rfbVM/mBi9J4Kbgi3S70r9eav0aJ8oHvnAd7xGnyP4Qtd5w0MH//YDj3Z07d91npcPdgQ75bqPBU8NrlGdB0f3keDm4EmJsz5/P6D8iIce7YPFIx/4jgfP+aG3vqCHv80Vevi3H3i0W++kQp3n5IMNwXa57hPB9sE9qvOg6D4UXBNsnThr8/fjyo84xLUOPNqJi86ggh55ryno2Qd6a8XDt/Va6/3ZXnWyb9d5puYpjPcvC57D80d17he9d81DEm9P/p4jH8QhrnXg0U5cdPqJV3dehA5+SvnhG137gneO6mTfrvPcfPAC78Vc9/fB9wdXq853Ru/R4NLg8Yn3ev6+Xz6Ihx7td4pHPvAdD57zQ+/1gh7+lhb08G3e8arz+1Un+2Z8cWKQ+QPj/yvUb+iX8D3PaBn9Un+dr+cS7Z4f1Z3P1H1OtJMf5wmPduLbl+vFegzrKZ/R9/KC6uV1m9OiW/qeF+q+p93rUnXXh+reXyfJj/OERzvx7cv9eHE+OC78TwbP1/tth/rx8OguCJ4c/dc0HvD7lXjo0T5cPPKB73iNvtfxha7zhtdJ/u0H3vmql/27zks0n2VeeEbw08HDqvPd0fN8dUewfeLOUn7EIa514NFOXHTuFq/u/Bkd/JTywze69gXv06qTfbv/Mw5kHPc5zU82q/97vNg5uqV5Efro0O5xbt1xad352Cny4zzh0U58+3K9eP/xXvoH1imYP6hefk+2i25pXRZ9dGj3+73u+7juenBz+XGe8Ggnvn25Hy/gg/DfF7wqyHrncvXju6I7L7g32CFxSuuyxEOP9rvEIx/4jtfoejC+0HXe8NrIv/3Au0r1sn/XeVE+2B9snes+G2R9c6XqPCy6zwZXBDslTml9lXjo0T5MPPKB73iNruva34qCHr7N66T311mqk33ztfIcWJX4rwfPDuFTwUuCp+ND62CjovtUcHewTeIezt9bg1Pli/jo0j5KPPKD77jwnOdUxbcefndX6FEH+4FHvazXRt/PJaqv6+Tn8zLVh3w+z/yh1Tv596jO5Hl64ixU3ugSx9fDo5146NzzV9b/ePko5fd53X/24/t5aeIe4L0Vwt8Frwx2D76p+3lE9J8LLg42S7y2wRfz+XTlS1zysB482omPzoiCHj4WF/TsB70XxaMO1mum+7S76mXf8K5UfV0nP9dX5IMjwX/KdZcHWwTf0HN9ZOLODp4a/RODS/L5NOVHPPRoHyke+cB3PHjOD70l4uELXedtPfzbDzza0bV/13ldPtgd7Jzrvqjv/4DqPDpxHwtuCXZNnNL9RxziWgfeOvVPdEYX9Mh7S0Gvbv84Uf7tBx7tjtu18LzZkvj7gl1C+FDwC8wPg3/W82ZC9J8JbgseCnZJ3JX5+2nlS3x0aZ8gHvnBd1x4zhO9lQU9/G6r0KMO9gOPelnvkHhfUH1dJ/cD7iPWo1lP/sfg1fq+uY77zOvXpyROx+AW5bdH/c46jd7fddfT8QPf+cLrLN8lH1erTvbtccpO3Yd879cEL9U4ZYruZ+6HM6L/tvJBlzi+Hh5xzLNe3fv8GvVf5+m48O3D9+WL8sP112qcv1/P58lt/rKvbolXmj8Qh7jWgUc7cdGZ/FfWue78prX82w+8a3U/2b/rvF3vf963X9LzZp/qPEnjCd7H3ROn9LwjHnq0TxKPfOA7XqPP2brjEnzDty94XVQn+6ZO8F9L3H/WPIh5Frwnc/2Z0SvNu9DjetqfLPCIi655ded7tFtvd8E3423Gy/8SPCjfHo+fFd0Zio8e19PueUbd8b7zmaH45qHrPO37d+HNhM/zoJV0c32/4OTgFMVHB11f1/QcK/BKeuQ1uaDnvKcoTz9P+oe3lPdZ62O4m/4ZHKPxxE3RG8G4M/hY8OHgvym//tKj/SbxyAe+48EbozxLce1vcUHPvh+Wr6bxt+r0mOrgOg8IbznvaZ4nwdnB8arzl6N3b/Dp4FPBgcF/V34DpEf7l8UjH/iOB2+88izFtZ+BytdxqcPThbiu01Oqg8dtA8NbGHwt+FZwnMZtX4nOUJ6zweeDP1U+A6VD+1fEIz58x4HnvH6q+NbDz5MFPft9Xr5crz7hTQ0eDjbP/b1J9bo+Ov/NPhj7EMFxygdd4vh6eLQTD53rC3rkOaug5/zHKc+m/T35nS9frldvxhmMTxhvBRepXtdF5+7gtOAzwWHKp7d0aL9OPOLDd5ym8VZB75mCHn6mFfTs9xn5ysdNdRuWDx7Ufc79eZT3fnBOq3def2t0f6T+yH09Jzg9OEj5Epc8rAdvmOKjc6t44+THeTXar+17kPzAc52my7/jwp+juH4v9QtvTXBvsFX6w6z8/Xu9l26M3gPBJ4LLgwOCv1F+/aRH+43ikQ98x4OHDnmW4trPAOXruNThiUJc12m56uB+MCQfbA8eCLbL9bvy9wvBR9QPvhHdScHngmuCU4OPBv9D+Q6RLu3fEI/84DsuvEeUbymu/T5X0LP/R+ULnus1VXVoWkdVfdeobu4HdxE3uCHYJtefEFyhfnBz9P4z+FBwVXBRcKTyIw5xrQOPduKic7N4G5S/84FnHyOVp/Xwv6qg5/oskn/XuW901wdb57r2jMvz+VzV+YbojQmuCK4NDg/eqfz6So/2G8QjH/iOBw8d8izFtZ/hytdxqcOKQlzXaa3q4OfNyHzwUHBHcD91jQ7vc97/XP/d6P44+Ejw2eASvfc9TiAueVgP3kjFR+e74u2QH+fV6DjG9Xi2oOd6LVEdmtarVM9pqpPHkXeGt4y65/rjgtM1jvxadO4JLg0uCPZRPuijQ/vXxCM+fMeB57z6KL718LO0oGe/C+TLz41B0WVeyXywba7nfcz7m+u+Gj3PQ1frfe33O3GIax14gxQXna+KV3deXHf8Yd9PyJfjwl+tuK7zA+HPD74dPBJcEByrOv8wekOCc4Ozg3cFf6L8HpAe7T8Uj3zgOx68scqzFNf+5hb07Psu+YLnOs1WHVznweGxzsQ6UofW79Sbrzp/PXpel9qoePYxWHq0f1088oHveI3Wr+56mv1vLPBcn7ny7+fsPeGtDR4MnhKdaXrOfjs6DwZnBNcFeysf9NGh/dviER++48BzXr0V33r4mVHQs9918uV6DQ1/dfD0XMe60kLV65bo3B/cGiytTw2VDu23iEd8+I7T6LqY/Wwt6Nnvk/Llfnwv9Q++GjwUZB7CPIjrvhO9vsH/Dc4MluZJxCGudeDdq7jofEe8V5W/82l0HndIdbAv86w3s1Dn4XoO85ztmO+L+3yt6vxNvX94Lm9SP3C/IQ5xrQNvuOKi803x6r5H6vZr+54hX44Lf5PiprnpOfBwPpgcZN2Q9b4zo3My80LGe7n+59H9r6DXG3cGVwZHKV/ikof14NFOfHR+Lt4i+XFeja6T2vco+bEe9dpZ0HM9V6pO7gcjorsyeHyu6xJkv2S5+sG3ondfcGFwW7C0/zJCerR/Szzyge94je772N/Cgp59Py1f8FynbaqD+8HEfMB6FOtNF+T6cxin5PM/qB/8LLpex9oX3BMcG/wf5TtRurT/TDzyg++48NAh31Jc+xqrfBtdr3Pd9hV4ruse1cv9YFJ0mY8yj+wWZF9nqvrBL6Ln+esLwdJ+0iTp0f4L8cgHvuM1uo9Vd95t37Pky3rwX5Ce6zwqeuxPsP/QPddz3mCm6vz96Hk/48Vg6fzCKOnR/n3xyAe+48Gre26i7j6MfU+WL+s18aXncfd94Z8a/mlBzhk0nV8I/3vRWR/cECyda0AfHdq/V+CRx/oCr+55CvtYrHzh2fcG+fPzeQrjxiDzJeY5ZwV57vM+4fpfRvd3Qc+zdun94PcOccnDevBoJz46vxRvmvw4r0bnh3Xfn67TQvl3XPi7FNfPjfs1PmN8c3aQ9b9lem78QONCxkO7g6X1ROKhR/sPxCMf+I7X6Dpm3fGgfS+VL+vB3y0913l04rKfwz5Mj2Cz4GbV+bboef/npeC84HjlRxziWgce7cRF5zbx6u5H2cd45QnPvufJl+PCf0lxXec/8V4Nsu/bNXgG6wqq8x3R837z9uCO4ETlRxziWgce7cRF5w7x6u5/28dE5Wk9/G8v6Lk+O+TfdX5c9w3fY0vGhfl8nur8a92vfO/Lgo8HByu/x6VH+6/FIx/4jgcPHfIsxa17P6ODf/uxnnnzCnWeoPkA4+4Lg+x77VCdb4+e5wUHgqV9NOIQ1zrwJiguOreLV3eeUnefz76flS/HhX9AcV3nx9Q/6Qd/G2Rfd73q/Cs9F+g3bwRL+8TEQ4/2X4lHPvAdD17d/em6zw37XiFf1oP/hvQ8Hnw+H3Dej/N8Hwx+IMj6LuvBXN8/uj4n+GZwf7C0bkx8dGnvLx75wXfcRter655zdD3eLPBcp63yD8913a96eX7DOQjOL1wU5PwI503g+7zEwWDpHAr66NA+XLy65zLqnn+xj1XK13HhH1Tcd/3eNfG3BF8Odsr1nYOv6LkxOnoTgn8Ibg5uCf5R+RGHuNaBRztx0Rkt3svK3/nAww985wuPePgu+XB9tkjP9yXzeObp5wbPY91W96Xn+y8HXwn6dxtVv8dodF3BeU1RfOvh5+WCnv2+Il/v+v2p5v3M1y8PfiTIPm3TezB6nv+f2O4YHs3fG5Vf1e8sGt0/rrseYV/kaZ79EveoeK7PUfn3fcm6KecXPxT8WJD1Uvg+B3mI+z36+5RP3XOUdddvneehgp7z36c84dkv7YcK9yXnXNgHYJ3/E8Ergm11X/r3JOwLtE68lkGfq6n6XQq8qvM3je5j2Ad6LVU/+8eP9VwfdOB7nMV+Lfu3f5PrLg5+WPcB9wXXe5/3z8G3gkd0//r+qdo3hld1/hce+aPrvBq9v6kDuvYHz3U6JP/Wg39Eeu4He3W/8b1+VvP1VuoHPj/GfdApWJrfV52Dh1f3vFrddYW6/cC+0esknuvUSf3fdeZ8CONkxsGf5Pmedn6PwXU+T8K4+eTE8e81yK/qd13wqs6vwKv6nQg8+5mjfBudN7hO6Owv3M/so3OulnO2VwavCp6p+9m/S+IcbtvE6xDcqfyqft8Er+7+ftW5YPPwRZ7m2S9xO+j7cH1ob1sYb7DuwbrGl5QP+cH3+kh36Tvvuueo667D1K2X/ZCn9ewXve6F9+Cb6j/cz9cHr9b4m/F407/XkPjuT+cEOwZL4/a6vwer2odstJ/XnVfYP7yO0nPd8O+4rmtH1cvfD+uhrO9fEvxo8NLgexj36PvxvsHhYIvEezt//19wmfxXrcc2ul/RUvmW4trv4YLee1QH+4HnuuH/sHiXFnjo+vvhXBrneJk/MT+6KXgt37e+H5+v9rzrvMTvFvS5uKrz2vCqzs/BqzqX3Oh80b6J2039wvXCt/VcT3Tg+717UL657otB9oHZF27698Xa/uV8uwa9b0x+VeeU4dU991i1X91one0bva7iuU5ddR+6zpzX4TzODcEbg6yzNledfb6nR/TPDZbWd6t+7w6v7nmiuuvK9ke+1rNv9M5VnV0n2nsU6sy5J/bf2V+/VXl1U539uyT24y9UPPuo+n0TvKrzWPDqnh+oW2f7x4/1XB/0LizUmXMk9BP6wc1B1hu6qM4+d0K/uUDrEY2e64RX95xL3XWTus8D+24tX9aDf4Gem35/cn6BfQf2FT4V/JzGAYwLuN6/02U/ok3iddZ73uOHqt/9wqs6Z9HoPkrd8Y3rgS/ruU7oddb347rS3qbw/bAP8b5gz+DHg72C56On74f9ir3B5sQJHhd8Le1b5KtqHwQe+cF3XHidlW8pbk/5dv7wzlcd7Afex1U/1wFeL9XXdfJzinNWzKOZJ/+rnos8J7nO5/OZV39Qz0U/R6vO+cOrOv/V6DpA3ee8/ePHeq7PhfLvOrPPzz7+j9Qv6aftVWefC+ip/ub9U/Kr+p08vLrnEKr2ba2HP/K1Xt3nkusED13//+uYZzM/vibIvl7Tvqzm4WcEvX9YtS/Y6Dzf+aB3hnjOn/aOBd+cG74lyD7bafLNOeIPRKe0n1d1DrkUF13z6u4jOn946Pr9wno269W3B2/Tfch9yXkarvc6+BXBXrrPfO6GfKvO9TW6/l513qfRfua64M9xXa+eqgM817eX6paPm55/nBNjn5N9zOuCPw7+JMj6I+uV6Ph3MOyDnh28LHi51iu9vln1+xp4Vefb4NXdx627/ur64M96rld3+YfnOl+musHz94DO/wPPoMh4eJydnHnQVmUZxtE0BQRT9k0EVDTNwMwMBRdMFrcUEbBSSC0nN8AlHStTQdMUSUVNR1RKy70al1JxwUxcp8IFp3JB0JJqcsFMBZuJ6/fN8LNn3ufAP9fM917nvu/rOud57vuc97wM69zuf/82XA3tPhnctsNq3D44MXhy8JDgHh3WPG5Fp9X4XnBg4u8W3DzYMbheuzXzkNdx4G2rvMRZId5E1e964O0hPaX6rHtz6XJe+Hw+sODz0PCGBUcH9w/uF/ycfP4AvYm7abBnsEdwpXwZqnh8/oF41APf+eC5PuL1EG+0dLpuePvLB+syj/w9xLPPO4S3b/Dg4LjgXsFd5fOH0dM9cTcL9gt2Dn5S9e3geJ3XjAePeuA7H7xdVWcp717S5TqdFx/Q5bz2qZ98sM9DdD1wfg4Pjg8Ol8/vR7evn22C/YMbqD7ykNdx4A1RXuK8L17t9Txcekr1WT96HM/+9Jd++7xjeLsEpwQvD14ZnCSfV0XP+om7bXBK8MjgINVHHvI6DrwdlZc4q+TzFNXveuBZxyDV6Xjon1KIZ3+OlP724W0QHBHe7sHJwZuDdwVPCu7D9ZXjN0zcDsFPB08Ofj84IthN9ZKXOhwP3gjlJ86G4k2WHtcFbx/pKtVnP04uxLNPI6Qfnn39vvzyOmB90Q8OCx4RPErrj+PcL7YOfib4Wa2/2r7TdN0fpvpdD7wjpM/1wrPebaTH8eB/VvHsM/s//eCbwROC3wgeKp/dL4YGvxgcEtyiYd+BN055idOvEI+6hxbiHSo9pfqse4h0wbNPX5QP3m/2DO+44PHB76l+9NDHOX6jxP1CcOfgaOUt9fs9FZfPNxKP+uA779rOGa3Oj30YKn3wjpeP9sM84o4Wz+tgbHjcBzDn/zz40+CXtQ66Jp7vG6YHjw/2Vn1jFY/Pu4pHPfCdD57r6638Te93rH96gWd/jpf+/LnN75H5w0HBacHLgvcEf0MfD46hTyZOp8TvG9wlODk4I3h2cPtgF9U/UvH5vJN41Avf+eGNUd2lvNPkg3XAsw/bS5fj4ePkQjz7PEO+wfN5OFu+ev0w39Kf6D8n0u+DU7V+PA/Tr4YHxwaHqb5WczW88cpLnP7i1fZX6xpe4FnvMOmBZ3/GSr99pr8fGzw9+B3VdZR8pv/vFPxScG/lazpPwKMe+M7X1L/TpdN1w7Pu4dJlHnGt3/36gPAODHKfwv3Fr4PMtczLHN8rcfsEfX9zVrA0V5OXOhwP3gHKT5xe4k2SHtfV9L6s9v7Afp1ViGc/T5ZPXgfMZ8xf3w2eETwleLTWgee5UcExwd2DO6i+bygenw8Rr3Z+PFp1lvJa36hCvFOk33rg2acx8sH9ekL+8HX1IfrC3ZoTmBt4XkqcAYm/nfoxfeVMzQ1+vkr9ExSfzweIR73wnb/2uS68I+WDdTTt17Xzlf2dLr+cF/6Zyuv1w5zNfPzD4Pm63rj+2p5rJx7z9PjgwbqOmt4vNb0PqF0X1jNK9TovPowv5LVPB8sH+zw9vFOZt4LnBWcGT5PPuybensH9g+OCBwRHqj7ykNdx4E1XXuLsKt4M1e964J0mPaX6zpMP1gVvpnyybvtM/6fPnxm8IPgDzVkc53lhn+AhwYMKc1vt3NFqvoN3pup3PfCsY6zqdDz0H1KIZ38Okn77zDri+r8oOIv+rv7CcV53k4ITg/uqD9f2q6br/AzVWcp7lnS5TufFh0mFvPZponywz1N1njk/PwlyHzdNPvs+g/N5XLB0XzhV8fjc91219zW196O117P1H1fg2Z/J0m+fWSfnBucErwj+WOuI41hHBwYPD349eITWEfWRh7yO03T9zlH9rgeedRyiOuFdIR+syzziHiGe76d4Hsf3BHwP8HDwZ+q/9GOO57mdv1+4MDhNfdh9m7zU4Xi1zw2bfu9RO1dY/3jpgme/pskH1wf/QtXndcC+xD51XXBe8KrgbK0D72PHBI8NHhU8tOF+CG+W8hJnYiEedR9TiDdbekr1XSX91gPPPh0rH+zzheFdHLw6eENwbvAS+Twh8b4a/GZwavDo4NdUH3nI6zjwLlRe4kwQ72rV73rgXSI9pfpukA/WBW+ufLJu7zf0ZdYT6+XW4C26Xrh+ON5zPevs28FTdJ59nbW6T2g6P9TuD7XrwPqPkS7nxbdvF/La11Pkl9cB/Zx+RB+5KXi9+j3HeT6l75wUPEH9vnbObTpn1PZT6zqpwLPe46QHnv05Qfq9DujT1wbvCN4ZvE31US/H08+/Ffxe8IzgqcpfmidKcwI86oPvvE39vEO6XT886z9JuuDZr1Plg3nkt19eB6w/1s29wfuCt6u/cJzX68zgOcHT1Idr+1XT/WGe6izltb6ZhXi3S7/1wLNP58gH+3y9zjPn8bfBx4OPyGevL877rOClwYsarlN4jxR4jld7nVrXrALPui+VLnj25SLpts83hvfL4APBhcEHg7+Szycm3unB84IXB88Pfkf1kYe8jgPvRuUlzoniPaD6XQ+8X0lPqb6F8sG64D0on6yb/Xj9IOeZ/WZB8FGdf/jery4I/qhw3mv3u9rrbYHqdR3wHpUe12me88JzH+R5AP2V9cZ1vTj4uyDff3O8nyN4nc4Lzg7OUL2tnkvAq/1+vnZeqN1frHuG9Dgefs0rxLOfs+WTr2f6A3PkE8Gn1Dfge76cE7xcfaB2Pm3ap1znnEI81z9TdcKz3suly/ssczn3908GX1Zd1Mlxfl5wWfAm5bOO2vuA2ucTtf5Z32WFeNY9R7rg2aeb5IP3jXt1Xp4NPhN8Ojhf8wjH+3xfE5wbvCJ4rua32jmn6XV2n+ot5Z0vfa7TefHlmkLep+Wb9cOzv3Plm9cB+z/9YFHwueDzmnPannepX1wdvDZ4neac2r7TdL5apPpdDzzruFR1wntOPliXecS9Tjz7/Fh4vw/+KfhS8M/BP8jnSxLvyuD1wRuDNwSvUn3kIa/jwHtMeYlziXh/Uv2uB94fpKdU30vywbrg/Vk+Wbd9fkTnmfPzanCp+i/HeS7nfN4avE39t3a+b9r3a69T67q1wLPeedIDz/7cJv2eN9hf2G9eCS4JvqB5w/vQzcFbgj9puI/Be0b5iDO3EI86by7Ee0E6SvVZ7y3S5T5IX6Vv/j34D9VFnfQFjnc/vit4t/KW+ker+ajpHFDbt2p9ty93FfLar5vlAzz7e7d88/XM75+6dVyN3YO8V8d7ePD5XdRLwZeDpffzWv2+yjzqeKnAq30v0DrOUr3wrPtl6fM+S/97MbgsuFz7EvsUx9Effx68PXin9ptSXy71W3jUA9/5mu6fy6TTdcOz7luly/Hg36l4vi75XQDvr/F+Wp+cp74d1+T79wO8x7Ys+JrqafX7A3jkMc/xat+3s45lBZ51viY93mfZF1j3bwffCf4z+Jr2b473fjI/eH/w18FfqH/V9oWm+9gS1VvK+5r0uU7nxZf5hbz/lG/WD8/+3i/fvG+8qut/RfC94L81h3Cc19MDwQXBh9Zyrmm6fl3fbcrveOh7oBDP+hdIHzz785D022f2mTeCbwXfVV3L5TP70B3B+4IPqi7rIA95Had2/4P3lup3PU19flc+WJd5jgcvf27zm/ft6a/0z22CPYM8N+F5DO+XEMfv69N/3w4uCfr5TdPfCcNr9XsBeK3eg2k6Z9Q+j7Jvl8kH58Xvtwt5fT6WyF/3EZ67ct/Eemf9tU+cfsEeHdc83s9rvU8sCr4efEX1tnr+C4+85jle7X1g7f5mHxYVePbpdemHZx9fkT8+P8wPvLd/j/wizqeDfXR+/H6/n9eT/x3NG9Tb6vcCTeecVr8XbPo9Q+11YZ/eKfDs4zL54/PDumW99Q92DK7K59yncf/X9n2T1vvfgs8GFwZL94mtnlM33Wdq70+t6y7VC88+LJQ+ePbtWflhHfD/Jh2+r6A+8rdj/9T8DN86Htec1/T+u6lftXOrdcxXvc4L/3Hl9Tz1tvjrBtcJ/kdzMMc5/5PBJ4IPB+9Xfa3m6qZ6iUOdpbx8ji7X6bz48GQhr316Qj7YZ+Yu5rCVwY+Cn0ic9+Sz57RHg48FnwouUH2t5r2mc/pK1e964FnHAtUJ7yP5YF3mEfcp8bw//1t6OK5DsGuwd5A+zvG+/yDfM8EXg0sL/b7V/UzTOaPWT+t8psCz7kXSA89+vSgf4NnPpfLJ+zPnc8PwN1Ld6IDPef5j8DnVUbquStcLPPLDd56mvqKDuK7XPMd7ruAX+wv7Tedgp+B68sv70OLg88GnG+5j8NZRPuI8UYhHnYsL8daTjlJ91vu8dHn90/+YKzYP9lJd1Ml+z/GeV94Ivqq8pb7Qqv82nZOa9qNWvtuXNwp57ddi+QDP/r4q39wHue5ZB12CmwUHaN/hOK+TvwT/Glyufad2vTXd77qoftcDbzPpc73wrPdF6XE8+MsVz+ugk84f52dwcOvgwODGWgdeZ5zXN4NvBf8efKHhuoXXSfmJ87x4tdfjxtJVqs9+vFmIN1B+WTc8+/qW/PI66KrzuW1wx+AO6qsc5+tjRXBV8MNCP2/Vp5tej65vqfI7HvpWFOJZ/yrpg2d/PpR++8y62So4JDhUdQ2Qz6yrfwXfD36gupquU3jUA9/5mvo3RDpdNzzrXiFd5hHX+u1ze10PnJ9Dg18J9pPPnj85n1tsvBq3DL6u+mrn2NrndLXXs3UQjzodD/3ocTz7Qxz4ngfZt+i7nwvupP0MvvvxymC7xH9T9bTq5033T9e5shDP9b+pOuFZL5+vLFyXzDs8Pzog+GXVRZ0c5+dRvZKnt/JZR+1zrdo5zHVTh+PV+mzd8HrLZ/vE5+S3z4N1Xr4Q3Dm4nfojx/k8rxNcN/iu5o3aftv0utpadZbybiddrtN58QFdzmuf1pUPH/t/+tW/hgdHBHdTH217/qT9ewPiB9sHV0lHbb+o7d/DVb/rgWcdxGsv3gj5YF3mEbe9ePb58+ENC44Mjg3uFdxFPn+E3sTtFOwa7BxcX/WRh7yOA+/zykucj+TzSNXveuDtIj2l+sbKB+uCt5d8su6P/T/9Os+cn1HBSeqjbf9Pv+Y+zucmwUHqo7XzY9P+XXudWtcmG/9/nnUPki549mUL6bbP7DO7B/cJjg7uoX2I49iHOgS7BTcNdtR+XbuvmUddHQq8nVVnKa/1dVP98PaQfuuBZ582lQ/2mb5K3zxQ+tC7k3x2H+6jukv9o9U81LTvN+1brc6b9XeQPtcHn897F3xmP987OCa4r9bZbvKZ/f5TwS7B7lpnpT5T6h/wqAe+8zXdD8ZIp+uGZ92bSJfjwe+ueL7f4P3Z/YL7B3nvhPdU4PNebY/E6xksvb/S6v1c86iD+ObVvjdjHfB6yi/r5vMeBb96Ki7HMU/3l19+X4f4pTm/1ffh8Fq9F9T0/qLWL+vtpeuAdej9mnV/kPbvtuez2jf6ah9uuv/X7kuup5vyOx78vopn3aMVl+PGSbf7DXH7NexTzkse4my6lrpddz/xrJv9Z0JwovajtufsOX5AcOBa7mfwyAff8eG5nu7K73jwByqedY9SXI6bJN3et4k7SPlr9/vaebJWt+seJJ73Q97D4nkZz7m+GuT9K/h+P47nYVsF39G+1Or9Oni174PVPt9z/cTbSjzr5fMtC371UVyO+xr7ivzy+2rEHxz07xha/e4AXqv34uC5LuINXku/rHewzv9/AR/E+bU=AQAAAACAAABgNgAAMAwAAA==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 + + diff --git a/geos-mesh/tests/data/fracture_res5_id.vtu b/geos-mesh/tests/data/fracture_res5_id.vtu new file mode 100644 index 00000000..0fba5b61 --- /dev/null +++ b/geos-mesh/tests/data/fracture_res5_id.vtu @@ -0,0 +1,52 @@ + + + + + + + AQAAAACAAABADQAABgMAAA==eJwtyMVSFgAAhVFduHDh+Ah2d2GD2I0NdnchJnZiYmCLgYmtKHZid3djgo0dG2f8z918c27B7Jn+LyVzoIX4BBfmk1yET3FRPs3F+AwX57N8Tkv4S+p5fym+wKX5IpfhS1yWL3M5vsJBfJWvaXl/Bb3ur8g3uBLf5Mp8i6vwba7KdziY7/I9DfFX0/v+UH7A1fkh1+BHXJMfcy1+wrX5KT/TOv66muqvx8+5Pr/gBvySG/IrbsSvuTG/4TQN8zfRdH9TfsvN+B035/fcgj9wS/7IrfgTf9Zwf4Rm+FvzF27DX7ktf+N2/J1nZgm0vX8Wd+BY7siddLa/M8/hudrFP4+7chx34/ncnRdwD17IPbmXLvL35sW8RPv4l3JfXsb9OJ7783IewCt4IEfqSv8gXsUJGuVfzYN5DQ/htTyU1/EwXs/DeYRu8EdzIm/Ukf5NPIo382jewmN4K4/lbTyOx+t2/wTewTt1oj+JJ/Eunsy7eQoncwzv4ak8Tff6p/M+3q8z/Ad4Jh/kWXyIY/kwz+YjPIfn6lH/PD7Gcdwya6DzuRUv4HCO0IX+1ryI2/BiXqJt/Uu5HS/j9hzPHXg5d+ROusLfmVdyF17FCdrVv5q78Rruzmu5B6/jntxL1/t78wbuw4m8Ufv6N3E/3sz9eQsP4K08kCN1m38Qb+co3sE7dbA/iYfwLh7Ku3kYJ/NwHqF7/NG8l0fyPt6vo/wHeDQf5DF8iMfyYR7H4/WIfwIf5Yl8jI/rJH8KT+YTPIVPcgyf4qk8TU/7p/MZPqs5sgWaU8/5c/F5vqC5/Xn0ov+S5vVf5nx8hfPzVS7ABfWavxBf5xta2F9Eb/pvaVH/bS7Gd7g43+USXFLv+UvxfX6gpf1l9KH/kZb1P+Zy/ISD+CmX5wr6zF+RU7kSP+fK/IJfahX/K67KrzmY33AIV9M0fyinc3V+yzX4Hb/Xmv4PXIs/cm3+xHW4rn721+MMrs9fuAF/5W/a0P+dG/EPbsw/OYyb6C9/U/7NzfgPN+e//A+qS/z/ + + + 3905.8931117 + + + 5326.4624283 + + + + + AQAAAACAAACgBgAAbgEAAA==eJwtxdciEAAAAEBRUmlpK9q0aEpbey/tTUMb0d57T6VBO+2NSGjvoflDHrp7uYCA/6o40EGu6moOdnWHuIZrupZDXdt1XNf1XN9hbuCGbuTGbuKmbuZwN3cLRzjSLd3Krd3Gbd3O7R3laHdwR3dyZ3dxjGPd1d3c3T3c070c596Odx/3dT/39wAP9CAneLCHeKiHebhHeKRHebTHeKzHebwneKInebITPcVTPc3TPcMzPcuzPcdzPc/zvcBJTvZCL/JiL3GKl3qZl3uFV3qVVzvVaU73Gmc402u9zuu9wRu9yZu9xVu9zdu9wzu9y7u9x3u9z/t9wAd9yId9xEd9zMd9wid9ylk+7TPO9lmf83lfcI5zfdGXfNlXfNXXfN03nOebvuXbvuO7vuf7fuCHfuTHfuKnzneBC/3MRS72c5f4hUtd5nK/9Cu/9hu/9Tu/9wd/9Cd/9hd/9Td/9w9X+Kd/+bf/+K//uRLqf1df + + + + + AQAAAACAAADgBAAAEgEAAA==eJwtxddCCAAAAMAiozSkoaGh0NAeqGhrSNEg7SFkJKFhlIhoaCBUP9tDdy8XEHAo0Ed81EE+5uM+4ZMOdohPOdRhDneETzvSZxzlaMc41mcd53gnONHnnORkpzjV553mdF/wRV9yhjOd5Wxfdo5zned8F7jQRS52iUt9xVd9zWUud4Wv+4YrXeVq17jWda73TTe40U1u9i23+LZb3eY7vut2d7jTXb7n++72A/e4133u94AHPeRhj3jUDz3mR37sJx73Uz/zc7/whF960q885dd+47ee9oxnPed3fu8P/uh5L/iTF/3ZX7zkr/7mZX/3D6941Wte909veNNb3vYv//Yf7/iv//m/d73nfR8ARZMvOw== + + + + + AQAAAACAAADwCQAAXQIAAA==eJxtlaFOK1EQhheFQZCKq1E3+xQN6Zm+QR8ATdKER1iPQVVvVhxxa6rQtNy6DcFhGzwJkhzF9ITO/93kVn3Z7M78Z86XTtP4r7/YN6dfey7enInvvv4Gdx/ih3dx/ybejOKnrfj1UXxYiz97cbMSX96LrzrxzS3yLJBhir4tek1QvzwHXr+IuwG8FDe/wKtd89/faob3E+qAB/H1i7gp4sPEkF/cT8XdQnxzK77qxJf34mYl/uzFh7X49RF9t+LNiAxv4od35PkQ333h27N5cHsu7i/I+/Wf3+nnHbG7F+zuBbt7we5esLunb0exuxfs7gW7e8HuXrC7F+zuBbt7we6e8iyQYYq+LXpNUL88B7t7qjOAl2J3D9l24qbB8xneT6gDHhL6JuRJyGnIbziX4byGORjmY5ibIZthzob5i9093JfY3cP9it09+CB29+DPHF6J3T2wO5bhXoZ7Ge5luJfhXoZ7p29HcXUvw70M9zLcy3Avw70M9zLcO+VZIMMUfVv0mqD+0b0M9051BvBSXN2LbDvx0b14PsP7CXXAQ0LfhDwJOQ35DecynNcwB8N8DHMzZDPM2TB/cXUv7ktc3Yv7FVf3wgdxdS/8mcMrcXUveB//+3XnlnAvuO7cEu4F151bwj19O4rrzi3hXnDduSXc0+5ZievOLeFecN25pzwLZJiib4teE9Q/7twS7qnOAF6K686NbLt/dqSez/B+Qh3wkNA3IU9CTkN+w7kM5zXMwTAfw9wM2QxzFtedG/eCvltx3blxv+K6c8MHcd254c8cXonrzi3pG10/Tpw= + + + 0 + + + 2304.8861143 + + + + + + + AQAAAACAAACAEwAAWQMAAA==eJxd1Vf7CAQYhnEjpKiUWYmiREX29rf33nvvvffee29KoShbpE2plJXxhRy474Oe9+R3Xff1nL/1Cz2/BjgFJ2M9rB99EtaNnX0ifho7+wSsEzv7eKwdO/s4/CR29rH4cezsY/Cj2NlHY63Y2UdhzdjZR+KHsbOPwBqxsw/HD2JnH4bvx84+FKvHzj4Eq8XOPhjfi519EL4bO/tArBo7+wCsEjt7f3wndvZ+WDl29r74duzsffCt2Nl745uxs/fCSrGz98SKsbP3wAqxs3fH8rGzd8NysbN3xbKxs3fBN2Jn74yvx87eCcvEzt4RX4udvQO+Gjt7e3wldvZ2WDp29rZYKnb2Nvhy7Oyt8aXY2QuwZOzsrfDF2NlbYonY2Vtg8djZm2Ox2Nmb4QuxszfForGzN8EisbM3xsKxszcq9P8rHL0h+k/8O5/jZzgpdvbjODF29mM4IXb2ozg+dvYjOC529sM4Nnb2QzgmdvaDODp29gM4Knb2/TgydvZ9OCJ29r04PHb2PTgsdvbdODR29l04JHb2nTg4dvYdOCh29u04MHb2bTggdvat2D929i3YL3b2zdg3dvZN2Cd29o3YO3b2Ddgrdvb12DN29nXYI3b2tdg9dvY12C129tXYNXb2VdgldvaV2Dl29hXYKXb25dgxdvZl2CF29qXYPnb2JdgudvbF2DZ29kXYJnb2hdg6dvYFWBA7+3xsFTv7PGwZO/tcbBE7+xxsHjv7bGwWO/ssbBo7+0xsEjv7DGwcO/t0bBQ7+zRsGDv7VPSf+Hee4hM8Hjv7YzwWO/sjPBo7+394JHb2h3g4dvYHeCh29vt4MHb2e3ggdva7uD929n9xX+zs/+De2Nnv4J7Y2f/G3bGz/4W7Ymf/E3fGzn4bd8TO/gduj539d9wWO/st3Bo7+03cEjv7b7g5dvZfcVPs7L/gxtjZf8YNsbP/hOtjZ/8R18XO/gOujZ39Bq6Jnf17XB07+3VcFTv7NVwZO/t3uCJ29qu4PHb2K7gsdvbLuDR29ku4JHb2i7g4dvYLuCh29vO4MHb2c7ggdvZvcX7s7N/gvNjZz+Lc2NnP4JzY2b/G2bGzf4WzYmc/jTNjZz+FM2JnP4nTY2f/EqfFzv4FTo2d/QQ+A6EeATg= + + + AQAAAACAAADgBAAADgEAAA==eJwtxRFwAgAAAMC2C4IgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCAaDwSAIgiAIgiAIBkEQDPqXDwbeQg474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aVXXnvjrb/87R//eue9Dz765LMvvvrmu//88NMvBz7eBR1y2BFHHXPcCSedctoZZ51z3gUXXXLZFVddc90NN91y2x133XPfAw898tgTTz3z3AsvvfLaG2/95W//+Nc7733w0SefffHVN9/954effjnw+S7okMOOOOqY40446ZTTzjjrnPMuuOiSy6646prrbrjpltvu+B9fwUXT + + + AQAAAACAAACcAAAADAAAAA==eJxjZx+8AABPhQRF + + + + + diff --git a/geos-mesh/tests/data/surface.vtu b/geos-mesh/tests/data/surface.vtu new file mode 100644 index 00000000..f6bd890b --- /dev/null +++ b/geos-mesh/tests/data/surface.vtu @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + 2526.2662269 + + + 4019.2067423 + + + + + + + 25.568730903 + + + 25.568730903 + + + + + + + + + + + 2516.6143322 + + + 4041.4536614 + + + + + + + + + + + + + _AQAAAACAAAAIAAAADQAAAA==eJxjYAABFQcAAJAAZQ==FAAAAACAAADgIwAAwTEAALozAAD6LAAAODIAAOQfAABeLwAAsjgAAGYwAAAjNgAAgTMAALoqAAC3IQAA7SgAAFw0AACyIQAApTMAACw3AACRLwAAHDYAAP4PAAA=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FAAAAACAAADgIwAAegAAAHgAAAB6AAAAegAAAHgAAAB6AAAAegAAAHgAAAB6AAAAegAAAHgAAAB6AAAAegAAAHgAAAB6AAAAegAAAHgAAAB6AAAAegAAAD8AAAA=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BwAAAACAAACgNgAATQAAAE0AAABNAAAATQAAAE0AAABNAAAAMgAAAA==eJztxUEBAAAEBLCLJIKKGtPD9llyajq2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bT9+AZ2VEPF4nO3FQQEAAAQEsIskgooa08P2WXJqOrZt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27ZtP34BnZUQ8Xic7cVBAQAABASwiySCihrTw/ZZcmo6tm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm0/fgGdlRDxeJztxUEBAAAEBLCLJIKKGtPD9llyajq2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bT9+AZ2VEPF4nO3FQQEAAAQEsIskgooa08P2WXJqOrZt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27ZtP34BnZUQ8Xic7cVBAQAABASwiySCihrTw/ZZcmo6tm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm0/fgGdlRDxeJztxTEBAAAIA6BFMoIVbawV/OEhOTUd27Zt27Zt27Zt27Zt27Zt27Zt27YfL8oT2y8=BQAAAACAAACkbgAA3UEAABtDAAA9SgAAyDoAABQ6AAA=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FAAAAACAAADgIwAAyRgAAAobAAA3HAAAhhsAADgbAAD7GwAAVRwAAMUaAAA0HQAAgR4AAPcaAAA0GwAAzhsAAPIbAABoGwAAMB0AAIkcAACgGwAAzB4AAL8HAAA=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BwAAAACAAACgNgAAlhgAAJcYAACXGAAAmBgAAJgYAACaGAAAmQoAAA==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AQAAAACAAADUZgAAMQAAAA==eJztwSEBAAAAwyC1/pUvXgMoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALgBhBUCQw== + + diff --git a/geos-mesh/tests/test_arrayHelpers.py b/geos-mesh/tests/test_arrayHelpers.py new file mode 100644 index 00000000..0a73ee99 --- /dev/null +++ b/geos-mesh/tests/test_arrayHelpers.py @@ -0,0 +1,199 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Paloma Martinez +# SPDX-License-Identifier: Apache 2.0 +# ruff: noqa: E402 # disable Module level import not at top of file +# mypy: disable-error-code="operator, attr-defined" +import pytest +from typing import Tuple + +import numpy as np +import numpy.typing as npt + +import vtkmodules.util.numpy_support as vnp +import pandas as pd # type: ignore[import-untyped] +from vtkmodules.vtkCommonCore import vtkDoubleArray +from vtkmodules.vtkCommonDataModel import vtkDataSet, vtkMultiBlockDataSet, vtkPolyData + +from geos.mesh.utils import arrayHelpers + + +@pytest.mark.parametrize( "onpoints, expected", [ ( True, { + 'GLOBAL_IDS_POINTS': 1, + 'collocated_nodes': 2, + 'PointAttribute': 3 +} ), ( False, { + 'CELL_MARKERS': 1, + 'PERM': 3, + 'PORO': 1, + 'FAULT': 1, + 'GLOBAL_IDS_CELLS': 1, + 'CellAttribute': 3 +} ) ] ) +def test_getAttributeFromMultiBlockDataSet( dataSetTest: vtkMultiBlockDataSet, onpoints: bool, + expected: dict[ str, int ] ) -> None: + """Test getting attribute list as dict from multiblock.""" + multiBlockTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + attributes: dict[ str, int ] = arrayHelpers.getAttributesFromMultiBlockDataSet( multiBlockTest, onpoints ) + + assert attributes == expected + + +@pytest.mark.parametrize( "onpoints, expected", [ ( True, { + 'GLOBAL_IDS_POINTS': 1, + 'PointAttribute': 3, +} ), ( False, { + 'CELL_MARKERS': 1, + 'PERM': 3, + 'PORO': 1, + 'FAULT': 1, + 'GLOBAL_IDS_CELLS': 1, + 'CellAttribute': 3 +} ) ] ) +def test_getAttributesFromDataSet( dataSetTest: vtkDataSet, onpoints: bool, expected: dict[ str, int ] ) -> None: + """Test getting attribute list as dict from dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + attributes: dict[ str, int ] = arrayHelpers.getAttributesFromDataSet( vtkDataSetTest, onpoints ) + assert attributes == expected + + +@pytest.mark.parametrize( "attributeName, onpoints, expected", [ + ( "PORO", False, 1 ), + ( "PORO", True, 0 ), +] ) +def test_isAttributeInObjectMultiBlockDataSet( dataSetTest: vtkMultiBlockDataSet, attributeName: str, onpoints: bool, + expected: dict[ str, int ] ) -> None: + """Test presence of attribute in a multiblock.""" + multiBlockDataset: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + obtained: bool = arrayHelpers.isAttributeInObjectMultiBlockDataSet( multiBlockDataset, attributeName, onpoints ) + assert obtained == expected + + +@pytest.mark.parametrize( "attributeName, onpoints, expected", [ + ( "PORO", False, 1 ), + ( "PORO", True, 0 ), +] ) +def test_isAttributeInObjectDataSet( dataSetTest: vtkDataSet, attributeName: str, onpoints: bool, + expected: bool ) -> None: + """Test presence of attribute in a dataset.""" + vtkDataset: vtkDataSet = dataSetTest( "dataset" ) + obtained: bool = arrayHelpers.isAttributeInObjectDataSet( vtkDataset, attributeName, onpoints ) + assert obtained == expected + + +@pytest.mark.parametrize( "arrayExpected, onpoints", [ + ( "PORO", False ), + ( "PERM", False ), + ( "PointAttribute", True ), +], + indirect=[ "arrayExpected" ] ) +def test_getArrayInObject( request: pytest.FixtureRequest, arrayExpected: npt.NDArray[ np.float64 ], + dataSetTest: vtkDataSet, onpoints: bool ) -> None: + """Test getting numpy array of an attribute from dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + params = request.node.callspec.params + attributeName: str = params[ "arrayExpected" ] + + obtained: npt.NDArray[ np.float64 ] = arrayHelpers.getArrayInObject( vtkDataSetTest, attributeName, onpoints ) + expected: npt.NDArray[ np.float64 ] = arrayExpected + + assert ( obtained == expected ).all() + + +@pytest.mark.parametrize( "arrayExpected, onpoints", [ + ( "PORO", False ), + ( "PointAttribute", True ), +], + indirect=[ "arrayExpected" ] ) +def test_getVtkArrayInObject( request: pytest.FixtureRequest, arrayExpected: npt.NDArray[ np.float64 ], + dataSetTest: vtkDataSet, onpoints: bool ) -> None: + """Test getting Vtk Array from a dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + params = request.node.callspec.params + attributeName: str = params[ 'arrayExpected' ] + + obtained: vtkDoubleArray = arrayHelpers.getVtkArrayInObject( vtkDataSetTest, attributeName, onpoints ) + obtained_as_np: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( obtained ) + + assert ( obtained_as_np == arrayExpected ).all() + + +@pytest.mark.parametrize( "attributeName, onpoints, expected", [ + ( "PORO", False, 1 ), + ( "PERM", False, 3 ), + ( "PointAttribute", True, 3 ), +] ) +def test_getNumberOfComponentsDataSet( + dataSetTest: vtkDataSet, + attributeName: str, + onpoints: bool, + expected: int, +) -> None: + """Test getting the number of components of an attribute from a dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + obtained: int = arrayHelpers.getNumberOfComponentsDataSet( vtkDataSetTest, attributeName, onpoints ) + assert obtained == expected + + +@pytest.mark.parametrize( "attributeName, onpoints, expected", [ + ( "PORO", False, 1 ), + ( "PERM", False, 3 ), + ( "PointAttribute", True, 3 ), +] ) +def test_getNumberOfComponentsMultiBlock( + dataSetTest: vtkMultiBlockDataSet, + attributeName: str, + onpoints: bool, + expected: int, +) -> None: + """Test getting the number of components of an attribute from a multiblock.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + obtained: int = arrayHelpers.getNumberOfComponentsMultiBlock( vtkMultiBlockDataSetTest, attributeName, onpoints ) + + assert obtained == expected + + +@pytest.mark.parametrize( "attributeName, onpoints, expected", [ + ( "PERM", False, ( "AX1", "AX2", "AX3" ) ), + ( "PORO", False, () ), +] ) +def test_getComponentNamesDataSet( dataSetTest: vtkDataSet, attributeName: str, onpoints: bool, + expected: tuple[ str, ...] ) -> None: + """Test getting the component names of an attribute from a dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + obtained: tuple[ str, ...] = arrayHelpers.getComponentNamesDataSet( vtkDataSetTest, attributeName, onpoints ) + assert obtained == expected + + +@pytest.mark.parametrize( "attributeName, onpoints, expected", [ + ( "PERM", False, ( "AX1", "AX2", "AX3" ) ), + ( "PORO", False, () ), +] ) +def test_getComponentNamesMultiBlock( + dataSetTest: vtkMultiBlockDataSet, + attributeName: str, + onpoints: bool, + expected: tuple[ str, ...], +) -> None: + """Test getting the component names of an attribute from a multiblock.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + obtained: tuple[ str, ...] = arrayHelpers.getComponentNamesMultiBlock( vtkMultiBlockDataSetTest, attributeName, + onpoints ) + assert obtained == expected + + +@pytest.mark.parametrize( "attributeNames, expected_columns", [ + ( ( "CellAttribute1", ), ( "CellAttribute1_0", "CellAttribute1_1", "CellAttribute1_2" ) ), + ( ( + "CellAttribute1", + "CellAttribute2", + ), ( "CellAttribute2", "CellAttribute1_0", "CellAttribute1_1", "CellAttribute1_2" ) ), +] ) +def test_getAttributeValuesAsDF( dataSetTest: vtkPolyData, attributeNames: Tuple[ str, ...], + expected_columns: Tuple[ str, ...] ) -> None: + """Test getting an attribute from a polydata as a dataframe.""" + polydataset: vtkPolyData = dataSetTest( "polydata" ) + data: pd.DataFrame = arrayHelpers.getAttributeValuesAsDF( polydataset, attributeNames ) + + obtained_columns = data.columns.values.tolist() + assert obtained_columns == list( expected_columns ) diff --git a/geos-mesh/tests/test_arrayModifiers.py b/geos-mesh/tests/test_arrayModifiers.py new file mode 100644 index 00000000..5f90bb13 --- /dev/null +++ b/geos-mesh/tests/test_arrayModifiers.py @@ -0,0 +1,289 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Paloma Martinez +# SPDX-License-Identifier: Apache 2.0 +# ruff: noqa: E402 # disable Module level import not at top of file +# mypy: disable-error-code="operator" +import pytest +from typing import Union, Tuple, cast + +import numpy as np +import numpy.typing as npt + +import vtkmodules.util.numpy_support as vnp +from vtkmodules.vtkCommonCore import vtkDataArray, vtkDoubleArray +from vtkmodules.vtkCommonDataModel import ( vtkDataSet, vtkMultiBlockDataSet, vtkDataObjectTreeIterator, vtkPointData, + vtkCellData ) + +from vtk import ( # type: ignore[import-untyped] + VTK_CHAR, VTK_DOUBLE, VTK_FLOAT, VTK_INT, VTK_UNSIGNED_INT, +) + +from geos.mesh.utils import arrayModifiers + + +@pytest.mark.parametrize( "attributeName, onpoints", [ ( "CellAttribute", False ), ( "PointAttribute", True ) ] ) +def test_fillPartialAttributes( + dataSetTest: vtkMultiBlockDataSet, + attributeName: str, + onpoints: bool, +) -> None: + """Test filling a partial attribute from a multiblock with nan values.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + arrayModifiers.fillPartialAttributes( vtkMultiBlockDataSetTest, attributeName, nbComponents=3, onPoints=onpoints ) + + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( vtkMultiBlockDataSetTest ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + dataset: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + data: Union[ vtkPointData, vtkCellData ] + if onpoints: + data = dataset.GetPointData() + else: + data = dataset.GetCellData() + assert data.HasArray( attributeName ) == 1 + + iter.GoToNextItem() + + +@pytest.mark.parametrize( "onpoints, expectedArrays", [ + ( True, ( "PointAttribute", "collocated_nodes" ) ), + ( False, ( "CELL_MARKERS", "CellAttribute", "FAULT", "PERM", "PORO" ) ), +] ) +def test_fillAllPartialAttributes( + dataSetTest: vtkMultiBlockDataSet, + onpoints: bool, + expectedArrays: tuple[ str, ...], +) -> None: + """Test filling all partial attributes from a multiblock with nan values.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + arrayModifiers.fillAllPartialAttributes( vtkMultiBlockDataSetTest, onpoints ) + + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( vtkMultiBlockDataSetTest ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + dataset: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + data: Union[ vtkPointData, vtkCellData ] + if onpoints: + data = dataset.GetPointData() + else: + data = dataset.GetCellData() + + for attribute in expectedArrays: + assert data.HasArray( attribute ) == 1 + + iter.GoToNextItem() + + +@pytest.mark.parametrize( "attributeName, dataType, expectedDatatypeArray", [ + ( "test_double", VTK_DOUBLE, "vtkDoubleArray" ), + ( "test_float", VTK_FLOAT, "vtkFloatArray" ), + ( "test_int", VTK_INT, "vtkIntArray" ), + ( "test_unsigned_int", VTK_UNSIGNED_INT, "vtkUnsignedIntArray" ), + ( "test_char", VTK_CHAR, "vtkCharArray" ), +] ) +def test_createEmptyAttribute( + attributeName: str, + dataType: int, + expectedDatatypeArray: vtkDataArray, +) -> None: + """Test empty attribute creation.""" + componentNames: tuple[ str, str, str ] = ( "d1", "d2", "d3" ) + newAttr: vtkDataArray = arrayModifiers.createEmptyAttribute( attributeName, componentNames, dataType ) + + assert newAttr.GetNumberOfComponents() == len( componentNames ) + for ax in range( 3 ): + assert newAttr.GetComponentName( ax ) == componentNames[ ax ] + assert newAttr.IsA( str( expectedDatatypeArray ) ) + + +@pytest.mark.parametrize( "onpoints, elementSize", [ + ( False, ( 1740, 156 ) ), + ( True, ( 4092, 212 ) ), +] ) +def test_createConstantAttributeMultiBlock( + dataSetTest: vtkMultiBlockDataSet, + onpoints: bool, + elementSize: Tuple[ int, ...], +) -> None: + """Test creation of constant attribute in multiblock dataset.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + attributeName: str = "testAttributemultiblock" + values: tuple[ float, float, float ] = ( 12.4, 10, 40.0 ) + componentNames: tuple[ str, str, str ] = ( "X", "Y", "Z" ) + arrayModifiers.createConstantAttributeMultiBlock( vtkMultiBlockDataSetTest, values, attributeName, componentNames, + onpoints ) + + iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() + iter.SetDataSet( vtkMultiBlockDataSetTest ) + iter.VisitOnlyLeavesOn() + iter.GoToFirstItem() + while iter.GetCurrentDataObject() is not None: + dataset: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) + data: Union[ vtkPointData, vtkCellData ] + if onpoints: + data = dataset.GetPointData() + else: + data = dataset.GetCellData() + createdAttribute: vtkDoubleArray = data.GetArray( attributeName ) + cnames: Tuple[ str, ...] = tuple( createdAttribute.GetComponentName( i ) for i in range( 3 ) ) + + assert ( vnp.vtk_to_numpy( createdAttribute ) == np.full( ( elementSize[ iter.GetCurrentFlatIndex() - 1 ], 3 ), + fill_value=values ) ).all() + assert cnames == componentNames + + iter.GoToNextItem() + + +@pytest.mark.parametrize( "values, onpoints, elementSize", [ + ( ( 42, 58, -103 ), True, 4092 ), + ( ( -42, -58, 103 ), False, 1740 ), +] ) +def test_createConstantAttributeDataSet( + dataSetTest: vtkDataSet, + values: list[ float ], + elementSize: int, + onpoints: bool, +) -> None: + """Test constant attribute creation in dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + componentNames: Tuple[ str, str, str ] = ( "XX", "YY", "ZZ" ) + attributeName: str = "newAttributedataset" + arrayModifiers.createConstantAttributeDataSet( vtkDataSetTest, values, attributeName, componentNames, onpoints ) + + data: Union[ vtkPointData, vtkCellData ] + if onpoints: + data = vtkDataSetTest.GetPointData() + + else: + data = vtkDataSetTest.GetCellData() + + createdAttribute: vtkDoubleArray = data.GetArray( attributeName ) + cnames: Tuple[ str, ...] = tuple( createdAttribute.GetComponentName( i ) for i in range( 3 ) ) + + assert ( vnp.vtk_to_numpy( createdAttribute ) == np.full( ( elementSize, 3 ), fill_value=values ) ).all() + assert cnames == componentNames + + +@pytest.mark.parametrize( "onpoints, arrayTest, arrayExpected", [ + ( True, 4092, "random_4092" ), + ( False, 1740, "random_1740" ), +], + indirect=[ "arrayTest", "arrayExpected" ] ) +def test_createAttribute( + dataSetTest: vtkDataSet, + arrayTest: npt.NDArray[ np.float64 ], + arrayExpected: npt.NDArray[ np.float64 ], + onpoints: bool, +) -> None: + """Test creation of dataset in dataset from given array.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + componentNames: tuple[ str, str, str ] = ( "XX", "YY", "ZZ" ) + attributeName: str = "AttributeName" + + arrayModifiers.createAttribute( vtkDataSetTest, arrayTest, attributeName, componentNames, onpoints ) + + data: Union[ vtkPointData, vtkCellData ] + if onpoints: + data = vtkDataSetTest.GetPointData() + else: + data = vtkDataSetTest.GetCellData() + + createdAttribute: vtkDoubleArray = data.GetArray( attributeName ) + cnames: Tuple[ str, ...] = tuple( createdAttribute.GetComponentName( i ) for i in range( 3 ) ) + + assert ( vnp.vtk_to_numpy( createdAttribute ) == arrayExpected ).all() + assert cnames == componentNames + + +def test_copyAttribute( dataSetTest: vtkMultiBlockDataSet ) -> None: + """Test copy of cell attribute from one multiblock to another.""" + objectFrom: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + objectTo: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + + attributeFrom: str = "CellAttribute" + attributeTo: str = "CellAttributeTO" + + arrayModifiers.copyAttribute( objectFrom, objectTo, attributeFrom, attributeTo ) + + blockIndex: int = 0 + blockFrom: vtkDataSet = cast( vtkDataSet, objectFrom.GetBlock( blockIndex ) ) + blockTo: vtkDataSet = cast( vtkDataSet, objectTo.GetBlock( blockIndex ) ) + + arrayFrom: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( blockFrom.GetCellData().GetArray( attributeFrom ) ) + arrayTo: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( blockTo.GetCellData().GetArray( attributeTo ) ) + + assert ( arrayFrom == arrayTo ).all() + + +def test_copyAttributeDataSet( dataSetTest: vtkDataSet, ) -> None: + """Test copy of cell attribute from one dataset to another.""" + objectFrom: vtkDataSet = dataSetTest( "dataset" ) + objectTo: vtkDataSet = dataSetTest( "dataset" ) + + attributNameFrom = "CellAttribute" + attributNameTo = "COPYATTRIBUTETO" + + arrayModifiers.copyAttributeDataSet( objectFrom, objectTo, attributNameFrom, attributNameTo ) + + arrayFrom: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( objectFrom.GetCellData().GetArray( attributNameFrom ) ) + arrayTo: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( objectTo.GetCellData().GetArray( attributNameTo ) ) + + assert ( arrayFrom == arrayTo ).all() + + +@pytest.mark.parametrize( "attributeName, onpoints", [ + ( "CellAttribute", False ), + ( "PointAttribute", True ), +] ) +def test_renameAttributeMultiblock( + dataSetTest: vtkMultiBlockDataSet, + attributeName: str, + onpoints: bool, +) -> None: + """Test renaming attribute in a multiblock dataset.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + newAttributeName: str = "new" + attributeName + arrayModifiers.renameAttribute( + vtkMultiBlockDataSetTest, + attributeName, + newAttributeName, + onpoints, + ) + block: vtkDataSet = cast( vtkDataSet, vtkMultiBlockDataSetTest.GetBlock( 0 ) ) + data: Union[ vtkPointData, vtkCellData ] + if onpoints: + data = block.GetPointData() + assert data.HasArray( attributeName ) == 0 + assert data.HasArray( newAttributeName ) == 1 + + else: + data = block.GetCellData() + assert data.HasArray( attributeName ) == 0 + assert data.HasArray( newAttributeName ) == 1 + + +@pytest.mark.parametrize( "attributeName, onpoints", [ ( "CellAttribute", False ), ( "PointAttribute", True ) ] ) +def test_renameAttributeDataSet( + dataSetTest: vtkDataSet, + attributeName: str, + onpoints: bool, +) -> None: + """Test renaming an attribute in a dataset.""" + vtkDataSetTest: vtkDataSet = dataSetTest( "dataset" ) + newAttributeName: str = "new" + attributeName + arrayModifiers.renameAttribute( object=vtkDataSetTest, + attributeName=attributeName, + newAttributeName=newAttributeName, + onPoints=onpoints ) + if onpoints: + assert vtkDataSetTest.GetPointData().HasArray( attributeName ) == 0 + assert vtkDataSetTest.GetPointData().HasArray( newAttributeName ) == 1 + + else: + assert vtkDataSetTest.GetCellData().HasArray( attributeName ) == 0 + assert vtkDataSetTest.GetCellData().HasArray( newAttributeName ) == 1 diff --git a/geos-mesh/tests/test_cli_parsing.py b/geos-mesh/tests/test_cli_parsing.py index 5a5f21bb..a73fe3f3 100644 --- a/geos-mesh/tests/test_cli_parsing.py +++ b/geos-mesh/tests/test_cli_parsing.py @@ -4,7 +4,7 @@ from typing import Iterator, Sequence from geos.mesh.doctor.checks.generate_fractures import FracturePolicy, Options from geos.mesh.doctor.parsing.generate_fractures_parsing import convert, display_results, fill_subparser -from geos.mesh.vtk.io import VtkOutput +from geos.mesh.io.vtkIO import VtkOutput @dataclass( frozen=True ) diff --git a/geos-mesh/tests/test_generate_fractures.py b/geos-mesh/tests/test_generate_fractures.py index f97d4be9..49f9bd82 100644 --- a/geos-mesh/tests/test_generate_fractures.py +++ b/geos-mesh/tests/test_generate_fractures.py @@ -8,7 +8,7 @@ from geos.mesh.doctor.checks.generate_cube import build_rectilinear_blocks_mesh, XYZ from geos.mesh.doctor.checks.generate_fractures import ( __split_mesh_on_fractures, Options, FracturePolicy, Coordinates3D, IDMapping ) -from geos.mesh.vtk.helpers import to_vtk_id_list +from geos.mesh.utils.genericHelpers import to_vtk_id_list FaceNodesCoords = tuple[ tuple[ float ] ] IDMatrix = Sequence[ Sequence[ int ] ] diff --git a/geos-mesh/tests/test_multiblockModifiers.py b/geos-mesh/tests/test_multiblockModifiers.py new file mode 100644 index 00000000..94b0650e --- /dev/null +++ b/geos-mesh/tests/test_multiblockModifiers.py @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. +# SPDX-FileContributor: Paloma Martinez +# SPDX-License-Identifier: Apache 2.0 +# ruff: noqa: E402 # disable Module level import not at top of file +import pytest + +from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet, vtkUnstructuredGrid +from geos.mesh.utils import multiblockModifiers + + +# TODO: Add test for keepPartialAttributes = True when function fixed +@pytest.mark.parametrize( + "keepPartialAttributes, expected_point_attributes, expected_cell_attributes", + [ + ( False, ( "GLOBAL_IDS_POINTS", ), ( "GLOBAL_IDS_CELLS", ) ), + # ( True, ( "GLOBAL_IDS_POINTS", ), ( "GLOBAL_IDS_CELLS", "CELL_MARKERS", "FAULT", "PERM", "PORO" ) ), + ] ) +def test_mergeBlocks( + dataSetTest: vtkMultiBlockDataSet, + expected_point_attributes: tuple[ str, ...], + expected_cell_attributes: tuple[ str, ...], + keepPartialAttributes: bool, +) -> None: + """Test the merging of a multiblock.""" + vtkMultiBlockDataSetTest: vtkMultiBlockDataSet = dataSetTest( "multiblock" ) + dataset: vtkUnstructuredGrid = multiblockModifiers.mergeBlocks( vtkMultiBlockDataSetTest, keepPartialAttributes ) + + assert dataset.GetCellData().GetNumberOfArrays() == len( expected_cell_attributes ) + for c_attribute in expected_cell_attributes: + assert dataset.GetCellData().HasArray( c_attribute ) + + assert dataset.GetPointData().GetNumberOfArrays() == len( expected_point_attributes ) + for p_attribute in expected_point_attributes: + assert dataset.GetPointData().HasArray( p_attribute ) \ No newline at end of file diff --git a/geos-mesh/tests/test_reorient_mesh.py b/geos-mesh/tests/test_reorient_mesh.py index 9bfd342d..5884d5f7 100644 --- a/geos-mesh/tests/test_reorient_mesh.py +++ b/geos-mesh/tests/test_reorient_mesh.py @@ -6,7 +6,7 @@ from vtkmodules.vtkCommonDataModel import vtkUnstructuredGrid, VTK_POLYHEDRON from geos.mesh.doctor.checks.reorient_mesh import reorient_mesh from geos.mesh.doctor.checks.vtk_polyhedron import FaceStream -from geos.mesh.vtk.helpers import to_vtk_id_list, vtk_iter +from geos.mesh.utils.genericHelpers import to_vtk_id_list, vtk_iter @dataclass( frozen=True ) diff --git a/geos-mesh/tests/test_supported_elements.py b/geos-mesh/tests/test_supported_elements.py index 6126b8ea..bb0213c6 100644 --- a/geos-mesh/tests/test_supported_elements.py +++ b/geos-mesh/tests/test_supported_elements.py @@ -5,7 +5,7 @@ from vtkmodules.vtkCommonDataModel import vtkUnstructuredGrid, VTK_POLYHEDRON # from geos.mesh.doctor.checks.supported_elements import Options, check, __check from geos.mesh.doctor.checks.vtk_polyhedron import parse_face_stream, FaceStream -from geos.mesh.vtk.helpers import to_vtk_id_list +from geos.mesh.utils.genericHelpers import to_vtk_id_list # TODO Update this test to have access to another meshTests file diff --git a/geos-posp/src/PVplugins/PVAttributeMapping.py b/geos-posp/src/PVplugins/PVAttributeMapping.py index 989d6394..a862b9a9 100644 --- a/geos-posp/src/PVplugins/PVAttributeMapping.py +++ b/geos-posp/src/PVplugins/PVAttributeMapping.py @@ -18,11 +18,11 @@ from geos.utils.Logger import Logger, getLogger from geos_posp.filters.AttributeMappingFromCellCoords import ( AttributeMappingFromCellCoords, ) -from geos_posp.processing.vtkUtils import ( - fillPartialAttributes, +from geos.mesh.utils.arrayModifiers import fillPartialAttributes +from geos.mesh.utils.multiblockModifiers import mergeBlocks +from geos.mesh.utils.arrayHelpers import ( getAttributeSet, getNumberOfComponents, - mergeBlocks, ) from geos_posp.visu.PVUtils.checkboxFunction import ( # type: ignore[attr-defined] createModifiedCallback, ) diff --git a/geos-posp/src/PVplugins/PVCreateConstantAttributePerRegion.py b/geos-posp/src/PVplugins/PVCreateConstantAttributePerRegion.py index 7aba2271..8f25df08 100644 --- a/geos-posp/src/PVplugins/PVCreateConstantAttributePerRegion.py +++ b/geos-posp/src/PVplugins/PVCreateConstantAttributePerRegion.py @@ -19,11 +19,11 @@ import vtkmodules.util.numpy_support as vnp from geos.utils.Logger import Logger, getLogger -from geos_posp.processing.multiblockInpectorTreeFunctions import ( +from geos.mesh.utils.multiblockHelpers import ( getBlockElementIndexesFlatten, getBlockFromFlatIndex, ) -from geos_posp.processing.vtkUtils import isAttributeInObject +from geos.mesh.utils.arrayHelpers import isAttributeInObject from paraview.util.vtkAlgorithm import ( # type: ignore[import-not-found] VTKPythonAlgorithmBase, smdomain, smhint, smproperty, smproxy, ) diff --git a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolume.py b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolume.py index cd0814f0..443f5fc3 100644 --- a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolume.py +++ b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolume.py @@ -24,7 +24,7 @@ from geos.utils.Logger import ERROR, INFO, Logger, getLogger from geos_posp.filters.GeosBlockExtractor import GeosBlockExtractor from geos_posp.filters.GeosBlockMerge import GeosBlockMerge -from geos_posp.processing.vtkUtils import ( +from geos.mesh.utils.arrayModifiers import ( copyAttribute, createCellCenterAttribute, ) diff --git a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurface.py b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurface.py index 6233809b..9a90cf3b 100644 --- a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurface.py +++ b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurface.py @@ -25,7 +25,7 @@ from geos.utils.Logger import ERROR, INFO, Logger, getLogger from geos_posp.filters.GeosBlockExtractor import GeosBlockExtractor from geos_posp.filters.GeosBlockMerge import GeosBlockMerge -from geos_posp.processing.vtkUtils import ( +from geos.mesh.utils.arrayModifiers import ( copyAttribute, createCellCenterAttribute, ) diff --git a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurfaceWell.py b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurfaceWell.py index 3de64962..3d041283 100644 --- a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurfaceWell.py +++ b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeSurfaceWell.py @@ -25,7 +25,7 @@ from geos.utils.Logger import ERROR, INFO, Logger, getLogger from geos_posp.filters.GeosBlockExtractor import GeosBlockExtractor from geos_posp.filters.GeosBlockMerge import GeosBlockMerge -from geos_posp.processing.vtkUtils import ( +from geos.mesh.utils.arrayModifiers import ( copyAttribute, createCellCenterAttribute, ) diff --git a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeWell.py b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeWell.py index 2519d41c..fd418b29 100644 --- a/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeWell.py +++ b/geos-posp/src/PVplugins/PVExtractMergeBlocksVolumeWell.py @@ -28,7 +28,7 @@ from geos.utils.Logger import ERROR, INFO, Logger, getLogger from geos_posp.filters.GeosBlockExtractor import GeosBlockExtractor from geos_posp.filters.GeosBlockMerge import GeosBlockMerge -from geos_posp.processing.vtkUtils import ( +from geos.mesh.utils.arrayModifiers import ( copyAttribute, createCellCenterAttribute, ) diff --git a/geos-posp/src/PVplugins/PVMergeBlocksEnhanced.py b/geos-posp/src/PVplugins/PVMergeBlocksEnhanced.py index 1bdc9666..23f81d87 100644 --- a/geos-posp/src/PVplugins/PVMergeBlocksEnhanced.py +++ b/geos-posp/src/PVplugins/PVMergeBlocksEnhanced.py @@ -16,7 +16,7 @@ import PVplugins # noqa: F401 from geos.utils.Logger import Logger, getLogger -from geos_posp.processing.vtkUtils import mergeBlocks +from geos.mesh.utils.multiblockModifiers import mergeBlocks from paraview.util.vtkAlgorithm import ( # type: ignore[import-not-found] VTKPythonAlgorithmBase, smdomain, smhint, smproperty, smproxy, ) diff --git a/geos-posp/src/PVplugins/PVMohrCirclePlot.py b/geos-posp/src/PVplugins/PVMohrCirclePlot.py index be2b5e7d..935cf61a 100644 --- a/geos-posp/src/PVplugins/PVMohrCirclePlot.py +++ b/geos-posp/src/PVplugins/PVMohrCirclePlot.py @@ -43,7 +43,8 @@ DEFAULT_FRICTION_ANGLE_RAD, DEFAULT_ROCK_COHESION, ) -from geos_posp.processing.vtkUtils import getArrayInObject, mergeBlocks +from geos.mesh.utils.arrayHelpers import getArrayInObject +from geos.mesh.utils.multiblockModifiers import mergeBlocks from geos_posp.visu.PVUtils.checkboxFunction import ( # type: ignore[attr-defined] createModifiedCallback, ) from geos_posp.visu.PVUtils.DisplayOrganizationParaview import ( diff --git a/geos-posp/src/PVplugins/PVSurfaceGeomechanics.py b/geos-posp/src/PVplugins/PVSurfaceGeomechanics.py index 4857c477..0d0b7ed5 100644 --- a/geos-posp/src/PVplugins/PVSurfaceGeomechanics.py +++ b/geos-posp/src/PVplugins/PVSurfaceGeomechanics.py @@ -21,7 +21,7 @@ DEFAULT_ROCK_COHESION, ) from geos_posp.filters.SurfaceGeomechanics import SurfaceGeomechanics -from geos_posp.processing.multiblockInpectorTreeFunctions import ( +from geos.mesh.utils.multiblockHelpers import ( getBlockElementIndexesFlatten, getBlockFromFlatIndex, ) diff --git a/geos-posp/src/PVplugins/PVTransferAttributesVolumeSurface.py b/geos-posp/src/PVplugins/PVTransferAttributesVolumeSurface.py index 046ba939..bbc5c1ad 100644 --- a/geos-posp/src/PVplugins/PVTransferAttributesVolumeSurface.py +++ b/geos-posp/src/PVplugins/PVTransferAttributesVolumeSurface.py @@ -17,11 +17,12 @@ from geos.utils.Logger import Logger, getLogger from geos_posp.filters.TransferAttributesVolumeSurface import ( TransferAttributesVolumeSurface, ) -from geos_posp.processing.multiblockInpectorTreeFunctions import ( +from geos.mesh.utils.multiblockHelpers import ( getBlockElementIndexesFlatten, getBlockFromFlatIndex, ) -from geos_posp.processing.vtkUtils import getAttributeSet, mergeBlocks +from geos.mesh.utils.arrayHelpers import getAttributeSet +from geos.mesh.utils.multiblockModifiers import mergeBlocks from geos_posp.visu.PVUtils.checkboxFunction import ( # type: ignore[attr-defined] createModifiedCallback, ) from geos_posp.visu.PVUtils.paraviewTreatments import getArrayChoices diff --git a/geos-posp/src/geos_posp/filters/AttributeMappingFromCellCoords.py b/geos-posp/src/geos_posp/filters/AttributeMappingFromCellCoords.py index 11332d1f..5f23d1b6 100644 --- a/geos-posp/src/geos_posp/filters/AttributeMappingFromCellCoords.py +++ b/geos-posp/src/geos_posp/filters/AttributeMappingFromCellCoords.py @@ -21,12 +21,8 @@ vtkCellLocator, vtkUnstructuredGrid, ) - -from geos_posp.processing.vtkUtils import ( - computeCellCenterCoordinates, - createEmptyAttribute, - getVtkArrayInObject, -) +from geos.mesh.utils.arrayModifiers import createEmptyAttribute +from geos.mesh.utils.arrayHelpers import ( getVtkArrayInObject, computeCellCenterCoordinates ) __doc__ = """ AttributeMappingFromCellCoords module is a vtk filter that map two identical mesh (or a mesh is diff --git a/geos-posp/src/geos_posp/filters/AttributeMappingFromCellId.py b/geos-posp/src/geos_posp/filters/AttributeMappingFromCellId.py index aa205f16..ceae6313 100644 --- a/geos-posp/src/geos_posp/filters/AttributeMappingFromCellId.py +++ b/geos-posp/src/geos_posp/filters/AttributeMappingFromCellId.py @@ -10,7 +10,8 @@ from vtkmodules.vtkCommonCore import vtkInformation, vtkInformationVector from vtkmodules.vtkCommonDataModel import vtkUnstructuredGrid -from geos_posp.processing.vtkUtils import createAttribute, getArrayInObject +from geos.mesh.utils.arrayModifiers import createAttribute +from geos.mesh.utils.arrayHelpers import getArrayInObject __doc__ = """ AttributeMappingFromCellId module is a vtk filter that transfer a attribute from a diff --git a/geos-posp/src/geos_posp/filters/GeomechanicsCalculator.py b/geos-posp/src/geos_posp/filters/GeomechanicsCalculator.py index cdd44a34..fb80122a 100644 --- a/geos-posp/src/geos_posp/filters/GeomechanicsCalculator.py +++ b/geos-posp/src/geos_posp/filters/GeomechanicsCalculator.py @@ -30,9 +30,8 @@ vtkUnstructuredGrid, ) from vtkmodules.vtkFiltersCore import vtkCellCenters - -from geos_posp.processing.vtkUtils import ( - createAttribute, +from geos.mesh.utils.arrayModifiers import createAttribute +from geos.mesh.utils.arrayHelpers import ( getArrayInObject, getComponentNames, isAttributeInObject, diff --git a/geos-posp/src/geos_posp/filters/GeosBlockExtractor.py b/geos-posp/src/geos_posp/filters/GeosBlockExtractor.py index 23c6bc48..7f8e030b 100644 --- a/geos-posp/src/geos_posp/filters/GeosBlockExtractor.py +++ b/geos-posp/src/geos_posp/filters/GeosBlockExtractor.py @@ -11,9 +11,9 @@ from vtkmodules.vtkCommonCore import vtkInformation, vtkInformationVector from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet -from geos_posp.processing.multiblockInpectorTreeFunctions import ( +from geos.mesh.utils.multiblockHelpers import ( getBlockIndexFromName, ) -from geos_posp.processing.vtkUtils import extractBlock +from geos.mesh.utils.multiblockHelpers import extractBlock __doc__ = """ GeosBlockExtractor module is a vtk filter that allows to extract Volume mesh, diff --git a/geos-posp/src/geos_posp/filters/GeosBlockMerge.py b/geos-posp/src/geos_posp/filters/GeosBlockMerge.py index e9f953e1..09b0a879 100644 --- a/geos-posp/src/geos_posp/filters/GeosBlockMerge.py +++ b/geos-posp/src/geos_posp/filters/GeosBlockMerge.py @@ -33,15 +33,11 @@ from vtkmodules.vtkFiltersGeometry import vtkDataSetSurfaceFilter from vtkmodules.vtkFiltersTexture import vtkTextureMapToPlane -from geos_posp.processing.multiblockInpectorTreeFunctions import ( - getElementaryCompositeBlockIndexes, ) -from geos_posp.processing.vtkUtils import ( - createConstantAttribute, - extractBlock, - fillAllPartialAttributes, - getAttributeSet, - mergeBlocks, -) +from geos.mesh.utils.multiblockHelpers import getElementaryCompositeBlockIndexes +from geos.mesh.utils.arrayHelpers import getAttributeSet +from geos.mesh.utils.arrayModifiers import createConstantAttribute, fillAllPartialAttributes +from geos.mesh.utils.multiblockHelpers import extractBlock +from geos.mesh.utils.multiblockModifiers import mergeBlocks __doc__ = """ GeosBlockMerge module is a vtk filter that allows to merge Geos ranks, rename diff --git a/geos-posp/src/geos_posp/filters/SurfaceGeomechanics.py b/geos-posp/src/geos_posp/filters/SurfaceGeomechanics.py index 849b14e4..7e50cbf7 100644 --- a/geos-posp/src/geos_posp/filters/SurfaceGeomechanics.py +++ b/geos-posp/src/geos_posp/filters/SurfaceGeomechanics.py @@ -33,8 +33,8 @@ from vtkmodules.vtkCommonDataModel import ( vtkPolyData, ) -from geos_posp.processing.vtkUtils import ( - createAttribute, +from geos.mesh.utils.arrayModifiers import createAttribute +from geos.mesh.utils.arrayHelpers import ( getArrayInObject, getAttributeSet, isAttributeInObject, diff --git a/geos-posp/src/geos_posp/filters/TransferAttributesVolumeSurface.py b/geos-posp/src/geos_posp/filters/TransferAttributesVolumeSurface.py index 1a2d911d..2640d625 100644 --- a/geos-posp/src/geos_posp/filters/TransferAttributesVolumeSurface.py +++ b/geos-posp/src/geos_posp/filters/TransferAttributesVolumeSurface.py @@ -19,7 +19,7 @@ from vtkmodules.vtkCommonDataModel import vtkPolyData, vtkUnstructuredGrid from geos_posp.filters.VolumeSurfaceMeshMapper import VolumeSurfaceMeshMapper -from geos_posp.processing.vtkUtils import ( +from geos.mesh.utils.arrayHelpers import ( getArrayInObject, getComponentNames, isAttributeInObject, diff --git a/geos-posp/src/geos_posp/processing/vtkUtils.py b/geos-posp/src/geos_posp/processing/vtkUtils.py deleted file mode 100644 index 09fa260c..00000000 --- a/geos-posp/src/geos_posp/processing/vtkUtils.py +++ /dev/null @@ -1,1011 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies. -# SPDX-FileContributor: Martin Lemay -from typing import Union, cast - -import numpy as np -import numpy.typing as npt -import pandas as pd # type: ignore[import-untyped] -import vtkmodules.util.numpy_support as vnp -from vtk import ( # type: ignore[import-untyped] - VTK_CHAR, VTK_DOUBLE, VTK_FLOAT, VTK_INT, VTK_UNSIGNED_INT, -) -from vtkmodules.vtkCommonCore import ( - vtkCharArray, - vtkDataArray, - vtkDoubleArray, - vtkFloatArray, - vtkIntArray, - vtkPoints, - vtkUnsignedIntArray, -) -from vtkmodules.vtkCommonDataModel import ( - vtkCellData, - vtkCompositeDataSet, - vtkDataObject, - vtkDataObjectTreeIterator, - vtkDataSet, - vtkMultiBlockDataSet, - vtkPlane, - vtkPointData, - vtkPointSet, - vtkPolyData, - vtkUnstructuredGrid, -) -from vtkmodules.vtkFiltersCore import ( - vtk3DLinearGridPlaneCutter, - vtkAppendDataSets, - vtkArrayRename, - vtkCellCenters, - vtkPointDataToCellData, -) -from vtkmodules.vtkFiltersExtraction import vtkExtractBlock - -from geos_posp.processing.multiblockInpectorTreeFunctions import ( - getBlockElementIndexesFlatten, - getBlockFromFlatIndex, -) - -__doc__ = """ Utilities to process vtk objects. """ - - -def getAttributeSet( object: Union[ vtkMultiBlockDataSet, vtkDataSet ], onPoints: bool ) -> set[ str ]: - """Get the set of all attributes from an object on points or on cells. - - Args: - object (Any): object where to find the attributes. - onPoints (bool): True if attributes are on points, False if they are on - cells. - - Returns: - set[str]: set of attribute names present in input object. - """ - attributes: dict[ str, int ] - if isinstance( object, vtkMultiBlockDataSet ): - attributes = getAttributesFromMultiBlockDataSet( object, onPoints ) - elif isinstance( object, vtkDataSet ): - attributes = getAttributesFromDataSet( object, onPoints ) - else: - raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) - - assert attributes is not None, "Attribute list is undefined." - - return set( attributes.keys() ) if attributes is not None else set() - - -def getAttributesWithNumberOfComponents( - object: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataSet, vtkDataObject ], - onPoints: bool, -) -> dict[ str, int ]: - """Get the dictionnary of all attributes from object on points or cells. - - Args: - object (Any): object where to find the attributes. - onPoints (bool): True if attributes are on points, False if they are on - cells. - - Returns: - dict[str, int]: dictionnary where keys are the names of the attributes - and values the number of components. - - """ - attributes: dict[ str, int ] - if isinstance( object, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): - attributes = getAttributesFromMultiBlockDataSet( object, onPoints ) - elif isinstance( object, vtkDataSet ): - attributes = getAttributesFromDataSet( object, onPoints ) - else: - raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) - return attributes - - -def getAttributesFromMultiBlockDataSet( object: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], - onPoints: bool ) -> dict[ str, int ]: - """Get the dictionnary of all attributes of object on points or on cells. - - Args: - object (vtkMultiBlockDataSet | vtkCompositeDataSet): object where to find - the attributes. - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - dict[str, int]: Dictionnary of the names of the attributes as keys, and - number of components as values. - - """ - attributes: dict[ str, int ] = {} - # initialize data object tree iterator - iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() - iter.SetDataSet( object ) - iter.VisitOnlyLeavesOn() - iter.GoToFirstItem() - while iter.GetCurrentDataObject() is not None: - dataSet: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) - blockAttributes: dict[ str, int ] = getAttributesFromDataSet( dataSet, onPoints ) - for attributeName, nbComponents in blockAttributes.items(): - if attributeName not in attributes: - attributes[ attributeName ] = nbComponents - - iter.GoToNextItem() - return attributes - - -def getAttributesFromDataSet( object: vtkDataSet, onPoints: bool ) -> dict[ str, int ]: - """Get the dictionnary of all attributes of a vtkDataSet on points or cells. - - Args: - object (vtkDataSet): object where to find the attributes. - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - dict[str, int]: List of the names of the attributes. - """ - attributes: dict[ str, int ] = {} - data: Union[ vtkPointData, vtkCellData ] - sup: str = "" - if onPoints: - data = object.GetPointData() - sup = "Point" - else: - data = object.GetCellData() - sup = "Cell" - assert data is not None, f"{sup} data was not recovered." - - nbAttributes = data.GetNumberOfArrays() - for i in range( nbAttributes ): - attributeName = data.GetArrayName( i ) - attribute = data.GetArray( attributeName ) - assert attribute is not None, f"Attribut {attributeName} is null" - nbComponents = attribute.GetNumberOfComponents() - attributes[ attributeName ] = nbComponents - return attributes - - -def isAttributeInObject( object: Union[ vtkMultiBlockDataSet, vtkDataSet ], attributeName: str, - onPoints: bool ) -> bool: - """Check if an attribute is in the input object. - - Args: - object (vtkMultiBlockDataSet | vtkDataSet): input object - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute is in the table, False otherwise - """ - if isinstance( object, vtkMultiBlockDataSet ): - return isAttributeInObjectMultiBlockDataSet( object, attributeName, onPoints ) - elif isinstance( object, vtkDataSet ): - return isAttributeInObjectDataSet( object, attributeName, onPoints ) - else: - raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) - - -def isAttributeInObjectMultiBlockDataSet( object: vtkMultiBlockDataSet, attributeName: str, onPoints: bool ) -> bool: - """Check if an attribute is in the input object. - - Args: - object (vtkMultiBlockDataSet): input multiblock object - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute is in the table, False otherwise - """ - iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() - iter.SetDataSet( object ) - iter.VisitOnlyLeavesOn() - iter.GoToFirstItem() - while iter.GetCurrentDataObject() is not None: - dataSet: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) - if isAttributeInObjectDataSet( dataSet, attributeName, onPoints ): - return True - iter.GoToNextItem() - return False - - -def isAttributeInObjectDataSet( object: vtkDataSet, attributeName: str, onPoints: bool ) -> bool: - """Check if an attribute is in the input object. - - Args: - object (vtkDataSet): input object - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute is in the table, False otherwise - """ - data: Union[ vtkPointData, vtkCellData ] - sup: str = "" - if onPoints: - data = object.GetPointData() - sup = "Point" - else: - data = object.GetCellData() - sup = "Cell" - assert data is not None, f"{sup} data was not recovered." - return bool( data.HasArray( attributeName ) ) - - -def getArrayInObject( object: vtkDataSet, attributeName: str, onPoints: bool ) -> npt.NDArray[ np.float64 ]: - """Return the numpy array corresponding to input attribute name in table. - - Args: - object (PointSet or UnstructuredGrid): input object - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - ArrayLike[float]: the array corresponding to input attribute name. - """ - array: vtkDoubleArray = getVtkArrayInObject( object, attributeName, onPoints ) - nparray: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( array ) # type: ignore[no-untyped-call] - return nparray - - -def getVtkArrayInObject( object: vtkDataSet, attributeName: str, onPoints: bool ) -> vtkDoubleArray: - """Return the array corresponding to input attribute name in table. - - Args: - object (PointSet or UnstructuredGrid): input object - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - vtkDoubleArray: the vtk array corresponding to input attribute name. - """ - assert isAttributeInObject( object, attributeName, onPoints ), f"{attributeName} is not in input object." - return object.GetPointData().GetArray( attributeName ) if onPoints else object.GetCellData().GetArray( - attributeName ) - - -def getNumberOfComponents( - dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataSet ], - attributeName: str, - onPoints: bool, -) -> int: - """Get the number of components of attribute attributeName in dataSet. - - Args: - dataSet (vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataSet): - dataSet where the attribute is. - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - int: number of components. - """ - if isinstance( dataSet, vtkDataSet ): - return getNumberOfComponentsDataSet( dataSet, attributeName, onPoints ) - elif isinstance( dataSet, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): - return getNumberOfComponentsMultiBlock( dataSet, attributeName, onPoints ) - else: - raise AssertionError( "Object type is not managed." ) - - -def getNumberOfComponentsDataSet( dataSet: vtkDataSet, attributeName: str, onPoints: bool ) -> int: - """Get the number of components of attribute attributeName in dataSet. - - Args: - dataSet (vtkDataSet): dataSet where the attribute is. - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - int: number of components. - """ - array: vtkDoubleArray = getVtkArrayInObject( dataSet, attributeName, onPoints ) - return array.GetNumberOfComponents() - - -def getNumberOfComponentsMultiBlock( - dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], - attributeName: str, - onPoints: bool, -) -> int: - """Get the number of components of attribute attributeName in dataSet. - - Args: - dataSet (vtkMultiBlockDataSet | vtkCompositeDataSet): multi block data Set where the attribute is. - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - int: number of components. - """ - elementraryBlockIndexes: list[ int ] = getBlockElementIndexesFlatten( dataSet ) - for blockIndex in elementraryBlockIndexes: - block: vtkDataSet = cast( vtkDataSet, getBlockFromFlatIndex( dataSet, blockIndex ) ) - if isAttributeInObject( block, attributeName, onPoints ): - array: vtkDoubleArray = getVtkArrayInObject( block, attributeName, onPoints ) - return array.GetNumberOfComponents() - return 0 - - -def getComponentNames( - dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataSet, vtkDataObject ], - attributeName: str, - onPoints: bool, -) -> tuple[ str, ...]: - """Get the name of the components of attribute attributeName in dataSet. - - Args: - dataSet (vtkDataSet | vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataObject): dataSet - where the attribute is. - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - tuple[str,...]: names of the components. - - """ - if isinstance( dataSet, vtkDataSet ): - return getComponentNamesDataSet( dataSet, attributeName, onPoints ) - elif isinstance( dataSet, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): - return getComponentNamesMultiBlock( dataSet, attributeName, onPoints ) - else: - raise AssertionError( "Object type is not managed." ) - - -def getComponentNamesDataSet( dataSet: vtkDataSet, attributeName: str, onPoints: bool ) -> tuple[ str, ...]: - """Get the name of the components of attribute attributeName in dataSet. - - Args: - dataSet (vtkDataSet): dataSet where the attribute is. - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - tuple[str,...]: names of the components. - - """ - array: vtkDoubleArray = getVtkArrayInObject( dataSet, attributeName, onPoints ) - componentNames: list[ str ] = [] - if array.GetNumberOfComponents() > 1: - componentNames += [ array.GetComponentName( i ) for i in range( array.GetNumberOfComponents() ) ] - return tuple( componentNames ) - - -def getComponentNamesMultiBlock( - dataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], - attributeName: str, - onPoints: bool, -) -> tuple[ str, ...]: - """Get the name of the components of attribute in MultiBlockDataSet. - - Args: - dataSet (vtkMultiBlockDataSet | vtkCompositeDataSet): dataSet where the - attribute is. - attributeName (str): name of the attribute - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - tuple[str,...]: names of the components. - """ - elementraryBlockIndexes: list[ int ] = getBlockElementIndexesFlatten( dataSet ) - for blockIndex in elementraryBlockIndexes: - block: vtkDataSet = cast( vtkDataSet, getBlockFromFlatIndex( dataSet, blockIndex ) ) - if isAttributeInObject( block, attributeName, onPoints ): - return getComponentNamesDataSet( block, attributeName, onPoints ) - return () - - -def fillPartialAttributes( - multiBlockMesh: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataObject ], - attributeName: str, - nbComponents: int, - onPoints: bool = False, -) -> bool: - """Fill input partial attribute of multiBlockMesh with nan values. - - Args: - multiBlockMesh (vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataObject): multiBlock - mesh where to fill the attribute - attributeName (str): attribute name - nbComponents (int): number of components - onPoints (bool, optional): Attribute is on Points (False) or - on Cells. - - Defaults to False. - - Returns: - bool: True if calculation successfully ended, False otherwise - """ - componentNames: tuple[ str, ...] = () - if nbComponents > 1: - componentNames = getComponentNames( multiBlockMesh, attributeName, onPoints ) - values: list[ float ] = [ np.nan for _ in range( nbComponents ) ] - createConstantAttribute( multiBlockMesh, values, attributeName, componentNames, onPoints ) - multiBlockMesh.Modified() - return True - - -def fillAllPartialAttributes( - multiBlockMesh: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataObject ], - onPoints: bool = False, -) -> bool: - """Fill all the partial attributes of multiBlockMesh with nan values. - - Args: - multiBlockMesh (vtkMultiBlockDataSet | vtkCompositeDataSet | vtkDataObject): - multiBlockMesh where to fill the attribute - onPoints (bool, optional): Attribute is on Points (False) or - on Cells. - - Defaults to False. - - Returns: - bool: True if calculation successfully ended, False otherwise - """ - attributes: dict[ str, int ] = getAttributesWithNumberOfComponents( multiBlockMesh, onPoints ) - for attributeName, nbComponents in attributes.items(): - fillPartialAttributes( multiBlockMesh, attributeName, nbComponents, onPoints ) - multiBlockMesh.Modified() - return True - - -def getAttributeValuesAsDF( surface: vtkPolyData, attributeNames: tuple[ str, ...] ) -> pd.DataFrame: - """Get attribute values from input surface. - - Args: - surface (vtkPolyData): mesh where to get attribute values - attributeNames (tuple[str,...]): tuple of attribute names to get the values. - - Returns: - pd.DataFrame: DataFrame containing property names as columns. - - """ - nbRows: int = surface.GetNumberOfCells() - data: pd.DataFrame = pd.DataFrame( np.full( ( nbRows, len( attributeNames ) ), np.nan ), columns=attributeNames ) - for attributeName in attributeNames: - if not isAttributeInObject( surface, attributeName, False ): - print( f"WARNING: Attribute {attributeName} is not in the mesh." ) - continue - array: npt.NDArray[ np.float64 ] = getArrayInObject( surface, attributeName, False ) - - if len( array.shape ) > 1: - for i in range( array.shape[ 1 ] ): - data[ attributeName + f"_{i}" ] = array[ :, i ] - data.drop( - columns=[ - attributeName, - ], - inplace=True, - ) - else: - data[ attributeName ] = array - return data - - -def extractBlock( multiBlockDataSet: vtkMultiBlockDataSet, blockIndex: int ) -> vtkMultiBlockDataSet: - """Extract the block with index blockIndex from multiBlockDataSet. - - Args: - multiBlockDataSet (vtkMultiBlockDataSet): multiblock dataset from which - to extract the block - blockIndex (int): block index to extract - - Returns: - vtkMultiBlockDataSet: extracted block - """ - extractBlockfilter: vtkExtractBlock = vtkExtractBlock() - extractBlockfilter.SetInputData( multiBlockDataSet ) - extractBlockfilter.AddIndex( blockIndex ) - extractBlockfilter.Update() - extractedBlock: vtkMultiBlockDataSet = extractBlockfilter.GetOutput() - return extractedBlock - - -def mergeBlocks( - input: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], - keepPartialAttributes: bool = False, -) -> vtkUnstructuredGrid: - """Merge all blocks of a multi block mesh. - - Args: - input (vtkMultiBlockDataSet | vtkCompositeDataSet ): composite - object to merge blocks - keepPartialAttributes (bool): if True, keep partial attributes after merge. - - Defaults to False. - - Returns: - vtkUnstructuredGrid: merged block object - - """ - if keepPartialAttributes: - fillAllPartialAttributes( input, False ) - fillAllPartialAttributes( input, True ) - - af = vtkAppendDataSets() - af.MergePointsOn() - iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() - iter.SetDataSet( input ) - iter.VisitOnlyLeavesOn() - iter.GoToFirstItem() - while iter.GetCurrentDataObject() is not None: - block: vtkUnstructuredGrid = vtkUnstructuredGrid.SafeDownCast( iter.GetCurrentDataObject() ) - af.AddInputData( block ) - iter.GoToNextItem() - af.Update() - return af.GetOutputDataObject( 0 ) - - -def createEmptyAttribute( - object: vtkDataObject, - attributeName: str, - componentNames: tuple[ str, ...], - dataType: int, - onPoints: bool, -) -> vtkDataArray: - """Create an empty attribute. - - Args: - object (vtkDataObject): object (vtkMultiBlockDataSet, vtkDataSet) - where to create the attribute - attributeName (str): name of the attribute - componentNames (tuple[str,...]): name of the components for vectorial - attributes - dataType (int): data type. - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute was correctly created - """ - # create empty array - newAttr: vtkDataArray - if dataType == VTK_DOUBLE: - newAttr = vtkDoubleArray() - elif dataType == VTK_FLOAT: - newAttr = vtkFloatArray() - elif dataType == VTK_INT: - newAttr = vtkIntArray() - elif dataType == VTK_UNSIGNED_INT: - newAttr = vtkUnsignedIntArray() - elif dataType == VTK_CHAR: - newAttr = vtkCharArray() - else: - raise ValueError( "Attribute type is unknown." ) - - newAttr.SetName( attributeName ) - newAttr.SetNumberOfComponents( len( componentNames ) ) - if len( componentNames ) > 1: - for i in range( len( componentNames ) ): - newAttr.SetComponentName( i, componentNames[ i ] ) - - return newAttr - - -def createConstantAttribute( - object: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet, vtkDataObject ], - values: list[ float ], - attributeName: str, - componentNames: tuple[ str, ...], - onPoints: bool, -) -> bool: - """Create an attribute with a constant value everywhere if absent. - - Args: - object (vtkDataObject): object (vtkMultiBlockDataSet, vtkDataSet) - where to create the attribute - values ( list[float]): list of values of the attribute for each components - attributeName (str): name of the attribute - componentNames (tuple[str,...]): name of the components for vectorial - attributes - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute was correctly created - """ - if isinstance( object, ( vtkMultiBlockDataSet, vtkCompositeDataSet ) ): - return createConstantAttributeMultiBlock( object, values, attributeName, componentNames, onPoints ) - elif isinstance( object, vtkDataSet ): - listAttributes: set[ str ] = getAttributeSet( object, onPoints ) - if attributeName not in listAttributes: - return createConstantAttributeDataSet( object, values, attributeName, componentNames, onPoints ) - return True - return False - - -def createConstantAttributeMultiBlock( - multiBlockDataSet: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ], - values: list[ float ], - attributeName: str, - componentNames: tuple[ str, ...], - onPoints: bool, -) -> bool: - """Create an attribute with a constant value everywhere if absent. - - Args: - multiBlockDataSet (vtkMultiBlockDataSet | vtkCompositeDataSet): vtkMultiBlockDataSet - where to create the attribute - values (list[float]): list of values of the attribute for each components - attributeName (str): name of the attribute - componentNames (tuple[str,...]): name of the components for vectorial - attributes - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute was correctly created - """ - # initialize data object tree iterator - iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() - iter.SetDataSet( multiBlockDataSet ) - iter.VisitOnlyLeavesOn() - iter.GoToFirstItem() - while iter.GetCurrentDataObject() is not None: - dataSet: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) - listAttributes: set[ str ] = getAttributeSet( dataSet, onPoints ) - if attributeName not in listAttributes: - createConstantAttributeDataSet( dataSet, values, attributeName, componentNames, onPoints ) - iter.GoToNextItem() - return True - - -def createConstantAttributeDataSet( - dataSet: vtkDataSet, - values: list[ float ], - attributeName: str, - componentNames: tuple[ str, ...], - onPoints: bool, -) -> bool: - """Create an attribute with a constant value everywhere. - - Args: - dataSet (vtkDataSet): vtkDataSet where to create the attribute - values ( list[float]): list of values of the attribute for each components - attributeName (str): name of the attribute - componentNames (tuple[str,...]): name of the components for vectorial - attributes - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute was correctly created - """ - nbElements: int = ( dataSet.GetNumberOfPoints() if onPoints else dataSet.GetNumberOfCells() ) - nbComponents: int = len( values ) - array: npt.NDArray[ np.float64 ] = np.ones( ( nbElements, nbComponents ) ) - for i, val in enumerate( values ): - array[ :, i ] *= val - createAttribute( dataSet, array, attributeName, componentNames, onPoints ) - return True - - -def createAttribute( - dataSet: vtkDataSet, - array: npt.NDArray[ np.float64 ], - attributeName: str, - componentNames: tuple[ str, ...], - onPoints: bool, -) -> bool: - """Create an attribute from the given array. - - Args: - dataSet (vtkDataSet): dataSet where to create the attribute - array (npt.NDArray[np.float64]): array that contains the values - attributeName (str): name of the attribute - componentNames (tuple[str,...]): name of the components for vectorial - attributes - onPoints (bool): True if attributes are on points, False if they are - on cells. - - Returns: - bool: True if the attribute was correctly created - """ - assert isinstance( dataSet, vtkDataSet ), "Attribute can only be created in vtkDataSet object." - - newAttr: vtkDataArray = vnp.numpy_to_vtk( array, deep=True, array_type=VTK_DOUBLE ) - newAttr.SetName( attributeName ) - - nbComponents: int = newAttr.GetNumberOfComponents() - if nbComponents > 1: - for i in range( nbComponents ): - newAttr.SetComponentName( i, componentNames[ i ] ) - - if onPoints: - dataSet.GetPointData().AddArray( newAttr ) - else: - dataSet.GetCellData().AddArray( newAttr ) - dataSet.Modified() - return True - - -def copyAttribute( - objectFrom: vtkMultiBlockDataSet, - objectTo: vtkMultiBlockDataSet, - attributNameFrom: str, - attributNameTo: str, -) -> bool: - """Copy an attribute from objectFrom to objectTo. - - Args: - objectFrom (vtkMultiBlockDataSet): object from which to copy the attribute. - objectTo (vtkMultiBlockDataSet): object where to copy the attribute. - attributNameFrom (str): attribute name in objectFrom. - attributNameTo (str): attribute name in objectTo. - - Returns: - bool: True if copy sussfully ended, False otherwise - """ - elementaryBlockIndexesTo: list[ int ] = getBlockElementIndexesFlatten( objectTo ) - elementaryBlockIndexesFrom: list[ int ] = getBlockElementIndexesFlatten( objectFrom ) - - assert elementaryBlockIndexesTo == elementaryBlockIndexesFrom, ( - "ObjectFrom " + "and objectTo do not have the same block indexes." ) - - for index in elementaryBlockIndexesTo: - # get block from initial time step object - blockT0: vtkDataSet = vtkDataSet.SafeDownCast( getBlockFromFlatIndex( objectFrom, index ) ) - assert blockT0 is not None, "Block at intitial time step is null." - - # get block from current time step object - block: vtkDataSet = vtkDataSet.SafeDownCast( getBlockFromFlatIndex( objectTo, index ) ) - assert block is not None, "Block at current time step is null." - try: - copyAttributeDataSet( blockT0, block, attributNameFrom, attributNameTo ) - except AssertionError: - # skip attribute if not in block - continue - return True - - -def copyAttributeDataSet( - objectFrom: vtkDataSet, - objectTo: vtkDataSet, - attributNameFrom: str, - attributNameTo: str, -) -> bool: - """Copy an attribute from objectFrom to objectTo. - - Args: - objectFrom (vtkDataSet): object from which to copy the attribute. - objectTo (vtkDataSet): object where to copy the attribute. - attributNameFrom (str): attribute name in objectFrom. - attributNameTo (str): attribute name in objectTo. - - Returns: - bool: True if copy sussfully ended, False otherwise - """ - # get attribut from initial time step block - npArray: npt.NDArray[ np.float64 ] = getArrayInObject( objectFrom, attributNameFrom, False ) - assert npArray is not None - componentNames: tuple[ str, ...] = getComponentNames( objectFrom, attributNameFrom, False ) - # copy attribut to current time step block - createAttribute( objectTo, npArray, attributNameTo, componentNames, False ) - objectTo.Modified() - return True - - -def renameAttribute( - object: Union[ vtkMultiBlockDataSet, vtkDataSet ], - attributeName: str, - newAttributeName: str, - onPoints: bool, -) -> bool: - """Rename an attribute. - - Args: - object (vtkMultiBlockDataSet): object where the attribute is - attributeName (str): name of the attribute - newAttributeName (str): new name of the attribute - onPoints (bool): True if attributes are on points, False if they are on cells. - - Returns: - bool: True if renaming operation successfully ended. - """ - if isAttributeInObject( object, attributeName, onPoints ): - dim: int = int( onPoints ) - filter = vtkArrayRename() - filter.SetInputData( object ) - filter.SetArrayName( dim, attributeName, newAttributeName ) - filter.Update() - object.ShallowCopy( filter.GetOutput() ) - else: - return False - return True - - -def createCellCenterAttribute( mesh: Union[ vtkMultiBlockDataSet, vtkDataSet ], cellCenterAttributeName: str ) -> bool: - """Create elementCenter attribute if it does not exist. - - Args: - mesh (vtkMultiBlockDataSet | vtkDataSet): input mesh - cellCenterAttributeName (str): Name of the attribute - - Raises: - TypeError: Raised if input mesh is not a vtkMultiBlockDataSet or a - vtkDataSet. - - Returns: - bool: True if calculation successfully ended, False otherwise. - """ - ret: int = 1 - if isinstance( mesh, vtkMultiBlockDataSet ): - # initialize data object tree iterator - iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator() - iter.SetDataSet( mesh ) - iter.VisitOnlyLeavesOn() - iter.GoToFirstItem() - while iter.GetCurrentDataObject() is not None: - block: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() ) - ret *= int( doCreateCellCenterAttribute( block, cellCenterAttributeName ) ) - iter.GoToNextItem() - elif isinstance( mesh, vtkDataSet ): - ret = int( doCreateCellCenterAttribute( mesh, cellCenterAttributeName ) ) - else: - raise TypeError( "Input object must be a vtkDataSet or vtkMultiBlockDataSet." ) - return bool( ret ) - - -def doCreateCellCenterAttribute( block: vtkDataSet, cellCenterAttributeName: str ) -> bool: - """Create elementCenter attribute in a vtkDataSet if it does not exist. - - Args: - block (vtkDataSet): input mesh that must be a vtkDataSet - cellCenterAttributeName (str): Name of the attribute - - Returns: - bool: True if calculation successfully ended, False otherwise. - """ - if not isAttributeInObject( block, cellCenterAttributeName, False ): - # apply ElementCenter filter - filter: vtkCellCenters = vtkCellCenters() - filter.SetInputData( block ) - filter.Update() - output: vtkPointSet = filter.GetOutputDataObject( 0 ) - assert output is not None, "vtkCellCenters output is null." - # transfer output to ouput arrays - centers: vtkPoints = output.GetPoints() - assert centers is not None, "Center are undefined." - centerCoords: vtkDataArray = centers.GetData() - assert centers is not None, "Center coordinates are undefined." - centerCoords.SetName( cellCenterAttributeName ) - block.GetCellData().AddArray( centerCoords ) - block.Modified() - return True - - -def computeCellCenterCoordinates( mesh: vtkDataSet ) -> vtkDataArray: - """Get the coordinates of Cell center. - - Args: - mesh (vtkDataSet): input surface - - Returns: - vtkPoints: cell center coordinates - """ - assert mesh is not None, "Surface is undefined." - filter: vtkCellCenters = vtkCellCenters() - filter.SetInputDataObject( mesh ) - filter.Update() - output: vtkUnstructuredGrid = filter.GetOutputDataObject( 0 ) - assert output is not None, "Cell center output is undefined." - pts: vtkPoints = output.GetPoints() - assert pts is not None, "Cell center points are undefined." - return pts.GetData() - - -def extractSurfaceFromElevation( mesh: vtkUnstructuredGrid, elevation: float ) -> vtkPolyData: - """Extract surface at a constant elevation from a mesh. - - Args: - mesh (vtkUnstructuredGrid): input mesh - elevation (float): elevation at which to extract the surface - - Returns: - vtkPolyData: output surface - """ - assert mesh is not None, "Input mesh is undefined." - assert isinstance( mesh, vtkUnstructuredGrid ), "Wrong object type" - - bounds: tuple[ float, float, float, float, float, float ] = mesh.GetBounds() - ooX: float = ( bounds[ 0 ] + bounds[ 1 ] ) / 2.0 - ooY: float = ( bounds[ 2 ] + bounds[ 3 ] ) / 2.0 - - # check plane z coordinates against mesh bounds - assert ( elevation <= bounds[ 5 ] ) and ( elevation >= bounds[ 4 ] ), "Plane is out of input mesh bounds." - - plane: vtkPlane = vtkPlane() - plane.SetNormal( 0.0, 0.0, 1.0 ) - plane.SetOrigin( ooX, ooY, elevation ) - - cutter = vtk3DLinearGridPlaneCutter() - cutter.SetInputDataObject( mesh ) - cutter.SetPlane( plane ) - cutter.SetInterpolateAttributes( True ) - cutter.Update() - return cutter.GetOutputDataObject( 0 ) - - -def transferPointDataToCellData( mesh: vtkPointSet ) -> vtkPointSet: - """Transfer point data to cell data. - - Args: - mesh (vtkPointSet): Input mesh. - - Returns: - vtkPointSet: Output mesh where point data were transferred to cells. - - """ - filter = vtkPointDataToCellData() - filter.SetInputDataObject( mesh ) - filter.SetProcessAllArrays( True ) - filter.Update() - return filter.GetOutputDataObject( 0 ) - - -def getBounds( - input: Union[ vtkUnstructuredGrid, - vtkMultiBlockDataSet ] ) -> tuple[ float, float, float, float, float, float ]: - """Get bounds of either single of composite data set. - - Args: - input (Union[vtkUnstructuredGrid, vtkMultiBlockDataSet]): input mesh - - Returns: - tuple[float, float, float, float, float, float]: tuple containing - bounds (xmin, xmax, ymin, ymax, zmin, zmax) - - """ - if isinstance( input, vtkMultiBlockDataSet ): - return getMultiBlockBounds( input ) - else: - return getMonoBlockBounds( input ) - - -def getMonoBlockBounds( input: vtkUnstructuredGrid, ) -> tuple[ float, float, float, float, float, float ]: - """Get boundary box extrema coordinates for a vtkUnstructuredGrid. - - Args: - input (vtkMultiBlockDataSet): input single block mesh - - Returns: - tuple[float, float, float, float, float, float]: tuple containing - bounds (xmin, xmax, ymin, ymax, zmin, zmax) - - """ - return input.GetBounds() - - -def getMultiBlockBounds( input: vtkMultiBlockDataSet, ) -> tuple[ float, float, float, float, float, float ]: - """Get boundary box extrema coordinates for a vtkMultiBlockDataSet. - - Args: - input (vtkMultiBlockDataSet): input multiblock mesh - - Returns: - tuple[float, float, float, float, float, float]: bounds. - - """ - xmin, ymin, zmin = 3 * [ np.inf ] - xmax, ymax, zmax = 3 * [ -1.0 * np.inf ] - blockIndexes: list[ int ] = getBlockElementIndexesFlatten( input ) - for blockIndex in blockIndexes: - block0: vtkDataObject = getBlockFromFlatIndex( input, blockIndex ) - assert block0 is not None, "Mesh is undefined." - block: vtkDataSet = vtkDataSet.SafeDownCast( block0 ) - bounds: tuple[ float, float, float, float, float, float ] = block.GetBounds() - xmin = bounds[ 0 ] if bounds[ 0 ] < xmin else xmin - xmax = bounds[ 1 ] if bounds[ 1 ] > xmax else xmax - ymin = bounds[ 2 ] if bounds[ 2 ] < ymin else ymin - ymax = bounds[ 3 ] if bounds[ 3 ] > ymax else ymax - zmin = bounds[ 4 ] if bounds[ 4 ] < zmin else zmin - zmax = bounds[ 5 ] if bounds[ 5 ] > zmax else zmax - return xmin, xmax, ymin, ymax, zmin, zmax diff --git a/geos-posp/src/geos_posp/pyvistaTools/pyvistaUtils.py b/geos-posp/src/geos_posp/pyvistaTools/pyvistaUtils.py index b4294dae..7c17e3ef 100644 --- a/geos-posp/src/geos_posp/pyvistaTools/pyvistaUtils.py +++ b/geos-posp/src/geos_posp/pyvistaTools/pyvistaUtils.py @@ -12,8 +12,9 @@ from vtkmodules.vtkCommonCore import vtkDataArray from vtkmodules.vtkCommonDataModel import ( vtkPolyData, ) - -import geos_posp.processing.vtkUtils as vtkUtils +from geos.mesh.utils.genericHelpers import extractSurfaceFromElevation +from geos.mesh.utils.arrayHelpers import ( getAttributeValuesAsDF, computeCellCenterCoordinates ) +from geos.mesh.utils.arrayModifiers import transferPointDataToCellData __doc__ = r""" This module contains utilities to process meshes using pyvista. @@ -61,14 +62,14 @@ def loadDataSet( assert mergedMesh is not None, "Merged mesh is undefined." # extract data - surface = vtkUtils.extractSurfaceFromElevation( mergedMesh, elevation ) + surface = extractSurfaceFromElevation( mergedMesh, elevation ) # transfer point data to cell center - surface = cast( vtkPolyData, vtkUtils.transferPointDataToCellData( surface ) ) - timeToPropertyMap[ str( time ) ] = vtkUtils.getAttributeValuesAsDF( surface, properties ) + surface = cast( vtkPolyData, transferPointDataToCellData( surface ) ) + timeToPropertyMap[ str( time ) ] = getAttributeValuesAsDF( surface, properties ) # get cell center coordinates assert surface is not None, "Surface are undefined." - pointsCoords: vtkDataArray = vtkUtils.computeCellCenterCoordinates( surface ) + pointsCoords: vtkDataArray = computeCellCenterCoordinates( surface ) assert pointsCoords is not None, "Cell center are undefined." pointsCoordsNp: npt.NDArray[ np.float64 ] = vnp.vtk_to_numpy( pointsCoords ) return ( timeToPropertyMap, pointsCoordsNp ) diff --git a/geos-posp/src/geos_posp/visu/PVUtils/paraviewTreatments.py b/geos-posp/src/geos_posp/visu/PVUtils/paraviewTreatments.py index ca36a4b9..ee09f715 100644 --- a/geos-posp/src/geos_posp/visu/PVUtils/paraviewTreatments.py +++ b/geos-posp/src/geos_posp/visu/PVUtils/paraviewTreatments.py @@ -32,7 +32,7 @@ vtkUnstructuredGrid, ) -from geos_posp.processing.vtkUtils import ( +from geos.mesh.utils.arrayHelpers import ( getArrayInObject, isAttributeInObject, ) diff --git a/pygeos-tools/src/geos/pygeos_tools/mesh/VtkMesh.py b/pygeos-tools/src/geos/pygeos_tools/mesh/VtkMesh.py index 5de6f2ec..67ce1a88 100644 --- a/pygeos-tools/src/geos/pygeos_tools/mesh/VtkMesh.py +++ b/pygeos-tools/src/geos/pygeos_tools/mesh/VtkMesh.py @@ -20,8 +20,8 @@ from vtkmodules.vtkCommonDataModel import vtkCellLocator, vtkFieldData, vtkImageData, vtkPointData, vtkPointSet from vtkmodules.vtkFiltersCore import vtkExtractCells, vtkResampleWithDataSet from vtkmodules.vtkFiltersExtraction import vtkExtractGrid -from geos.mesh.vtk.helpers import getCopyNumpyArrayByName, getNumpyGlobalIdsArray, getNumpyArrayByName -from geos.mesh.vtk.io import VtkOutput, read_mesh, write_mesh +from geos.mesh.utils.arrayHelpers import getNumpyArrayByName, getNumpyGlobalIdsArray +from geos.mesh.io.vtkIO import VtkOutput, read_mesh, write_mesh from geos.pygeos_tools.model.pyevtk_tools import cGlobalIds from geos.utils.errors_handling.classes import required_attributes @@ -175,7 +175,7 @@ def extractMesh( self: Self, Accessors """ - def getArray( self: Self, name: str, dtype: str = "cell", copy: bool = False, sorted: bool = False ) -> npt.NDArray: + def getArray( self: Self, name: str, dtype: str = "cell", sorted: bool = False ) -> npt.NDArray: """ Return a cell or point data array. If the file is a pvtu, the array is sorted with global ids @@ -185,8 +185,6 @@ def getArray( self: Self, name: str, dtype: str = "cell", copy: bool = False, so Name of the vtk cell/point data array dtype : str Type of vtk data `cell` or `point` - copy : bool - Return a copy of the requested array. Default is False sorted : bool Return the array sorted with respect to GlobalPointIds or GlobalCellIds. Default is False @@ -197,10 +195,7 @@ def getArray( self: Self, name: str, dtype: str = "cell", copy: bool = False, so """ assert dtype.lower() in ( "cell", "point" ) fdata = self.getCellData() if dtype.lower() == "cell" else self.getPointData() - if copy: - array = getCopyNumpyArrayByName( fdata, name, sorted=sorted ) - else: - array = getNumpyArrayByName( fdata, name, sorted=sorted ) + array = getNumpyArrayByName( fdata, name, sorted=sorted ) return array def getBounds( self: Self ) -> Iterable[ float ]: