diff --git a/cmake/Modules/SetFortranFlags.cmake b/cmake/Modules/SetFortranFlags.cmake index 403bc6ed0..76f23f5cf 100644 --- a/cmake/Modules/SetFortranFlags.cmake +++ b/cmake/Modules/SetFortranFlags.cmake @@ -158,7 +158,7 @@ SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}" # Strict model for floating-point calculations (precise and except) SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}" - Fortran "-fp-model strict" # Intel + Fortran "-fp-model=strict" # Intel ) # Enables floating-point invalid, divide-by-zero, and overflow exceptions @@ -273,11 +273,6 @@ SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-align all" # Intel ) -# Assume all objects are contiguous in memory -SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" - Fortran "-assume contiguous_assumed_shape" # Intel - ) - # Generate an extended set of vector functions SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-vecabi=cmdtarget" # Intel @@ -289,17 +284,17 @@ SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" ) # Generate fused multiply-add instructions -SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" - Fortran "-fma" # Intel - ) + SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" + Fortran "-fma" # Intel + ) # Generate fused multiply-add instructions -SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" - Fortran "-qmkl=cluster" # Intel - Fortran "-qmkl" # Intel - Fortran "-mkl" # Old Intel - ) - + SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" + Fortran "-qmkl=cluster" # Intel + Fortran "-qmkl" # Intel + Fortran "-mkl" # Old Intel + ) + ##################### ### MATH FLAGS ### ##################### diff --git a/examples/rmvs_swifter_comparison/.gitignore b/examples/rmvs_swifter_comparison/.gitignore index ecf4c57c8..4d901ba7d 100644 --- a/examples/rmvs_swifter_comparison/.gitignore +++ b/examples/rmvs_swifter_comparison/.gitignore @@ -1,3 +1,4 @@ * !.gitignore !1pl_1tp_encounter +!8pl_16tp_encounters diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/.gitignore b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/.gitignore new file mode 100644 index 000000000..89c2a1c6c --- /dev/null +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/.gitignore @@ -0,0 +1,5 @@ +* +!.gitignore +!init_cond.py +!swiftest_vs_swifter.py +!swiftest_vs_swifter.ipynb diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py new file mode 100755 index 000000000..d59c068d6 --- /dev/null +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +import numpy as np +import swiftest + +tstart = 0.0 +dt = 1.0 +tstop = 365.25e2 +tstep_out = 100*dt + +sim = swiftest.Simulation(simdir="swiftest_sim",init_cond_format="XV",output_format="XV",general_relativity=False, integrator="RMVS", rhill_present=True, MU="Msun", DU="AU", TU="d") +sim.clean() +sim.add_solar_system_body(["Sun","Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"]) + +plname = sim.init_cond['name'].where(sim.init_cond['name'] != "Sun", drop=True) +pl = sim.init_cond.sel(name=plname) + +for i,n in enumerate(pl.name): + pli = pl.sel(name=n) + rstart = 2 * pli['radius'].data[0] # Start the test particles at a multiple of the planet radius away + vstart = 1.5 * np.sqrt(2 * pli['Gmass'].data[0]) / rstart # Start the test particle velocities at a multiple of the escape speed + rstart_vec = np.array([rstart / np.sqrt(2.0), rstart / np.sqrt(2.0), 0.0]) + vstart_vec = np.array([vstart, 0.0, 0.0]) + rp = pli['rh'].data[0] + vp = pli['vh'].data[0] + sim.add_body(name=[f"TestParticle{100+i}",f"TestParticle{200+i}"],rh=[rp+rstart_vec, rp-rstart_vec],vh=[vp+vstart_vec, vp-vstart_vec]) + + +sim.set_parameter(tstart=tstart, tstop=tstop, dt=dt, tstep_out=tstep_out, dump_cadence=0) +sim.save() + +sim.set_parameter(simdir="swifter_sim",codename="Swifter",init_cond_file_type="ASCII",output_file_type="REAL8") +sim.save() diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_vs_swifter.ipynb b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_vs_swifter.ipynb new file mode 100644 index 000000000..322bbb1d2 --- /dev/null +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_vs_swifter.ipynb @@ -0,0 +1,229 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import swiftest" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading Swifter file /home/daminton/git_debug/swiftest/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swifter_sim/param.in\n", + "Reading in time 2.330e+04\n", + "Creating Dataset\n", + "Successfully converted 234 output frames.\n", + "Swifter simulation data stored as xarray DataSet .data\n" + ] + } + ], + "source": [ + "swiftersim = swiftest.Simulation(simdir=\"swifter_sim\", read_data=True, codename=\"Swifter\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading Swiftest file /home/daminton/git_debug/swiftest/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_sim/param.in\n", + "\n", + "Creating Dataset from NetCDF file\n", + "Successfully converted 1 output frames.\n", + "\n", + "Creating Dataset from NetCDF file\n", + "Successfully converted 367 output frames.\n", + "Swiftest simulation data stored as xarray DataSet .data\n", + "Reading initial conditions file as .init_cond\n", + "Finished reading Swiftest dataset files.\n" + ] + } + ], + "source": [ + "swiftestsim = swiftest.Simulation(simdir=\"swiftest_sim\",read_data=True)\n", + "swiftestsim.data = swiftestsim.data.swap_dims({\"name\" : \"id\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "swiftdiff = swiftestsim.data - swiftersim.data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "plid = swiftdiff['id'].where(swiftdiff['id'] < 9, drop=True)\n", + "tpid = swiftdiff['id'].where(swiftdiff['id'] >= 9, drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "swiftdiff.sel(id=plid)['rh'].plot(x=\"time\",hue=\"id\",col=\"space\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABCUAAAF8CAYAAAD4sQEKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRaklEQVR4nO3de3xU1bn/8e+e3BNCIEBIUkiIF1ABY0REFCWoBaKiFG+oBwG16pFLbawXtCq0Cl5aDlZ+orYaaKtieypItQellYAchEIwBxTkZhAQYgQhgdxmMrN+f0BGA0lIJjPZmcnnfV5zyuy9Zq9n7ZDH5GGttS1jjBEAAAAAAEArc9gdAAAAAAAAaJ8oSgAAAAAAAFtQlAAAAAAAALagKAEAAAAAAGxBUQIAAAAAANiCogQAAAAAALAFRQkAAAAAAGALihIAAAAAAMAW4XYHAAAAAABAqHK73XK5XHaHYZvIyEg5HA3Ph6AoAQAAAACAnxljVFxcrMOHD9sdiq0cDocyMjIUGRlZ73nLGGNaOSYAAAAAAELa/v37dfjwYSUlJSk2NlaWZdkdUqvzeDzat2+fIiIilJaWVu89YKYEAAAAAAB+5Ha7vQWJLl262B2Orbp166Z9+/appqZGERERJ51no0sAAAAAAPyodg+J2NhYmyOxX+2yDbfbXe95ihIAAAAAAARAe1yycaJT3QOKEgAAAAAAwBYUJQAAAAAACHLZ2dm6//77Gzzfq1cvzZkzp9XiaSo2ugQAAAAAIMi988479W4k2dZRlAAAAAAAIMglJibaHYJPWL4BAAAAAECQ++HyjZKSEo0aNUoxMTHKyMjQG2+8YW9wjWCmBAAAAAAAIWTChAnas2ePPvroI0VGRmrq1KkqKSmxO6x6UZQAAAAAACBEbNu2Tf/zP/+jNWvWaNCgQZKk1157TWeffbbNkdWP5RsAAAAAAISILVu2KDw8XBdccIH32FlnnaVOnTrZF1QjKEoAAAAAABAijDGSJMuybI6kaShKAAAAAAAQIs4++2zV1NRo/fr13mNbt27V4cOH7QuqERQlAAAAAAAIEX369NHIkSP105/+VGvXrlVBQYHuuusuxcTE2B1avShKAAAAAAAQQvLy8tSzZ08NHTpUY8aM0d13362kpCS7w6qXZWoXnAAAAAAAgBarqqpSUVGRMjIyFB0dbXc4tjrVvWCmBAAAAAAAsAVFCQAAAAAAYAuKEgAAAAAAwBYUJQAAAAAAgC0oSgAAAAAAAFtQlAAAAAAAALagKAEAAAAAAGxBUQIAAAAAANiCogQAAAAAALAFRQkAAAAAAGALihIAAAAAAECSdOTIEd1///1KT09XTEyMLr74Yq1bty5g/VGUAAAAAAAAkqS77rpLy5Yt05/+9Cdt2rRJw4cP15VXXqmvv/46IP1ZxhgTkCsDAAAAANAOVVVVqaioSBkZGYqOjpYxRpUuty2xxESEybKsJrWtrKxUfHy83n33XV199dXe4+edd56uueYaPfXUU83u/8R7caLwZl8RAAAAAAA0WaXLrXOe+MCWvjf/aoRiI5v2q39NTY3cbvdJxYOYmBitWrUqEOGxfAMAAAAAAEjx8fEaPHiwfv3rX2vfvn1yu93685//rLVr12r//v0B6ZOZEgAAAAAABFBMRJg2/2qEbX03x5/+9Cfdcccd+tGPfqSwsDCdf/75uvXWW7Vhw4aAxEdRAgAAAACAALIsq8lLKOx2+umna8WKFSovL1dZWZlSUlJ08803KyMjIyD9sXwDAAAAAADUERcXp5SUFB06dEgffPCBrrvuuoD0ExylGgAAAAAAEHAffPCBjDHq06ePduzYoQcffFB9+vTRxIkTA9IfMyUAAAAAAIAkqbS0VJMmTdJZZ52l22+/XUOGDNGHH36oiIiIgPRnGWNMQK4MAAAAAEA7VFVVpaKiImVkZJz0eM325lT3gpkSAAAAAADAFhQlAAAAAACALShKAAAAAAAAW1CUAAAAAAAAtqAoAQAAAAAAbEFRAgAAAAAA2IKiBAAAAAAAsAVFCQAAAAAAYAuKEgAAAAAAwBYUJRA0/vu//1v9+/dXTEyMunTpoiuvvFLl5eWSpAkTJmj06NGaMWOGkpKS1LFjR91zzz1yOp3ezy9dulRDhgxRp06d1KVLF11zzTXauXNnnT727t2rsWPHKjExUXFxcbrgggu0du1a7/m///3vGjBggKKjo3XaaadpxowZqqmpCch4jTG68sorNXLkSBljJEmHDx9WWlqaHnvssYD0CaB1tbe8tmvXLjkcDq1fv77O8RdffFHp6eneXAcgeLW3vCZJvXr1kmVZJ72AYLVy5UqNGjVKqampsixLixcvrnPeGKPp06crNTVVMTExys7O1ueff+5zfxQlEBT279+vW265RXfccYe2bNmi/Px8jRkzps4PsP/617+0ZcsWLV++XG+99ZYWLVqkGTNmeM+Xl5crNzdX69at07/+9S85HA795Cc/kcfjkSQdPXpUQ4cO1b59+7RkyRL93//9nx566CHv+Q8++ED/8R//oalTp2rz5s165ZVXNH/+fD399NMNxv3GG2+oQ4cOjb7eeOONej9rWZYWLFigf//73/rd734nSbr33nvVvXt3TZ8+vaW3FIDN2mNe69Wrl6688krl5eXVOZ6Xl6cJEybwQzwQ5NpjXpOkdevWaf/+/dq/f7/27t2riy66SJdeemlLbydgm/LycmVmZmru3Ln1nn/uuec0e/ZszZ07V+vWrVNycrJ+/OMf68iRI751aNqhFStWmGuuucakpKQYSWbRokVtor/NmzebUaNGmY4dO5oOHTqYQYMGma+++iqgsQWLgoICI8ns2rWr3vPjx483iYmJpry83Hts3rx5pkOHDsbtdtf7mZKSEiPJbNq0yRhjzCuvvGLi4+PNwYMH621/6aWXmpkzZ9Y59qc//cmkpKQ0GHdZWZnZvn17o6+ysrJGx/6Xv/zFREVFmWnTppnY2FizdevWRtsDCA7tNa+9/fbbpnPnzqaqqsoYY0xhYaGxLMsUFRU1+BkAwaG95rUfmjp1qklPTzclJSVNao/QVVlZaTZv3mwqKyvtDqVFTvz91ePxmOTkZPPMM894j1VVVZmEhATz8ssv13uNU92LcN9KGcGttvIzceJEXX/99W2iv507d2rIkCG68847NWPGDCUkJGjLli2Kjo4OeHzBIDMzU1dccYX69++vESNGaPjw4brhhhvUuXPnOm1iY2O97wcPHqyjR49qz549Sk9P186dO/X4449rzZo1OnDggLeivnv3bvXr10+FhYXKyspSYmJivTEUFBRo3bp1dSrtbrdbVVVVqqioqNN3rfj4eMXHx7do7DfeeKMWLVqkWbNmad68eerdu3eLrgegbWiveW306NGaPHmyFi1apLFjx+r111/XsGHD1KtXL5+vCaBtaK95rdarr76q1157Tf/7v/+rbt26tfh6CDHGSK4Ke/qOiJX8NBuxqKhIxcXFGj58uPdYVFSUhg4dqtWrV+uee+5p9jXbZVEiJydHOTk5DZ53Op365S9/qTfeeEOHDx9Wv3799Oyzzyo7Ozsg/UnSY489pquuukrPPfec99hpp53mU3+hKCwsTMuWLdPq1av14Ycf6sUXX9Rjjz2mtWvXKiMjo9HP1k4HHjVqlHr27Knf//73Sk1NlcfjUb9+/bzrGGNiYhq9jsfj0YwZMzRmzJiTzjVUPHrjjTdO+Y35yiuv6LbbbmvwfEVFhQoKChQWFqbt27c3ei0AwaO95rXIyEiNGzdOeXl5GjNmjN58803NmTOn0esBCA7tNa9JUn5+vqZMmaK33npLmZmZjV4L7ZSrQpqZak/fj+6TIuP8cqni4mJJUvfu3esc7969u7766iufrtkuixKnMnHiRO3atUsLFy5UamqqFi1apJEjR2rTpk0688wz/d6fx+PR+++/r4ceekgjRozQp59+qoyMDE2bNk2jR4/2e3/ByrIsXXLJJbrkkkv0xBNPKD09XYsWLVJubq4k6f/+7/9UWVnp/Y/VmjVr1KFDB/Xo0UMHDx7Uli1b9Morr3jX+K1atarO9c8991z94Q9/0HfffVdv9f3888/X1q1bdcYZZzQ55muvvVaDBg1qtM2J39AneuCBB+RwOPQ///M/uuqqq3T11Vfr8ssvb3IMANqu9prX7rrrLvXr108vvfSSXC5Xvb88AAhO7TGv7dixQ9dff70effRR8hnajRP3gTLG+Lw3FEWJE+zcuVNvvfWW9u7dq9TUY5WsX/ziF1q6dKny8vI0c+ZMv/dZUlKio0eP6plnntFTTz2lZ599VkuXLtWYMWO0fPlyDR061O99Bpu1a9fqX//6l4YPH66kpCStXbtW3377rc4++2xvG6fTqTvvvFO//OUv9dVXX+nJJ5/U5MmT5XA41LlzZ3Xp0kWvvvqqUlJStHv3bj3yyCN1+rjllls0c+ZMjR49WrNmzVJKSoo+/fRTpaamavDgwXriiSd0zTXXqGfPnrrxxhvlcDi0ceNGbdq0SU899VS9cbd0OuD777+v119/XZ988onOP/98PfLIIxo/frw2btxYZyokgODTXvOaJJ199tm66KKL9PDDD+uOO+445b98AggO7TGvVVZWatSoUTrvvPN09913e/8VWZKSk5N9uiZCVETssRkLdvXtJ7V/r4uLi5WSkuI9XlJScsp/lGiQPzfBCEY6YeOOv/zlL0aSiYuLq/MKDw83N910kzHGmKKiIiOp0dekSZOa1J8xxnz99ddGkrnlllvqHB81apQZO3asX8cbrDZv3mxGjBhhunXrZqKiokzv3r3Niy++6D0/fvx4c91115knnnjCdOnSxXTo0MHcdddd3o3UjDFm2bJl5uyzzzZRUVHm3HPPNfn5+Sd9PXbt2mWuv/5607FjRxMbG2suuOACs3btWu/5pUuXmosvvtjExMSYjh07mgsvvNC8+uqrARlzSUmJ6d69e53Nmlwul7nwwgu9fxcBBK/2mNd+6LXXXjOSzL///e+A9wWgdbTHvNbY7wVo30J9o8tnn33We6y6urpFG11axztqtyzL0qJFi7zLJN5++23ddttt+vzzzxUWFlanbYcOHZScnCyXy3XS85JP1Llz53orRSf2Jx2rGMfFxenJJ5/UL3/5S+/xhx9+WKtWrdL//u//+j7AdmLChAk6fPjwSc/QBYBgFep57emnn9bChQu1adMmu0MB0EpCPa8BP1RVVaWioiJlZGQE3cMLjh49qh07dkiSsrKyNHv2bA0bNkyJiYlKS0vTs88+q1mzZikvL09nnnmmZs6cqfz8fG3durXeWUenuhcs3zhBVlaW3G63SkpKGny+cEREhM466yy/9RkZGamBAwdq69atdY5v27ZN6enpfusHAAC7HT16VFu2bNGLL76oX//613aHAwAATrB+/XoNGzbM+752T5jx48dr/vz5euihh1RZWan77rtPhw4d0qBBg/Thhx/6vAyqXRYlflj5kY491qSwsFCJiYnq3bu3brvtNt1+++367W9/q6ysLB04cEAfffSR+vfvr6uuusqv/aWlpUmSHnzwQd1888267LLLNGzYMC1dulR///vflZ+f3+LxAgDQVkyePFlvvfWWRo8erTvuuMPucAAAwAmys7PV2IIKy7I0ffp0TZ8+3S/9tcvlG/n5+XUqP7VqKz8ul0tPPfWU/vjHP+rrr79Wly5dNHjwYM2YMUP9+/f3e3+1Xn/9dc2aNUt79+5Vnz59NGPGDF133XXN7g8AAAAAYJ9gXr7hb6e6F+2yKAEAAAAAQKBQlPjeqe6Fw4aYAAAAAAAAKEoAAAAAAAB7tKuNLj0ej/bt26f4+HhZlmV3OADaIWOMjhw5otTUVDkcLasLk9MAtAXkNQChxJ85DU3TrooS+/btU8+ePe0OAwC0Z88e9ejRo0XXIKcBaEvIawBCiT9yGpqmXRUlap+bumfPHnXs2NHmaAC0R2VlZerZs6fPz3H+IXIagLaAvAYglPgzp6Fp2lVRonYaYMeOHfkPHQBb+WNaMjkNQFtCXgMQSlhC1nqCZpHMrFmzNHDgQMXHxyspKUmjR4/W1q1b7Q4LAAAAAAD4KGiKEitWrNCkSZO0Zs0aLVu2TDU1NRo+fLjKy8vtDg0AAAAAAPggaIoSS5cu1YQJE9S3b19lZmYqLy9Pu3fvVkFBgd2hAQAAAAAQElauXKlRo0YpNTVVlmVp8eLFdc6/8847GjFihLp27SrLslRYWNii/oKmKHGi0tJSSVJiYmKDbaqrq1VWVlbnBQDBipwGINSQ1wCg7SkvL1dmZqbmzp3b4PlLLrlEzzzzjF/6C8qNLo0xys3N1ZAhQ9SvX78G282aNUszZsxoxcgAIHDIaQBCDXkNANqenJwc5eTkNHh+3LhxkqRdu3b5pb+gLEpMnjxZGzdu1KpVqxptN23aNOXm5nrf1z7eBQCCETkNQKghryFQ9m37Qgf27GpS2/7DhstyBO0EcgQJY4wqaypt6TsmPKZNP00k6IoSU6ZM0ZIlS7Ry5Ur16NGj0bZRUVGKiopqpcgAILDIaQBCDXkNgVBRVqq3pz8ij7umSe37Dfux2u6vawgVlTWVGvTmIFv6XnvrWsVGxNrSd1METVHCGKMpU6Zo0aJFys/PV0ZGht0hAQAAAGhjSkuK5XHXKDwqSun9z7M7HACnEDRFiUmTJunNN9/Uu+++q/j4eBUXF0uSEhISFBMTY3N0AAAAANqCitLDkqQuP+qp0Q8+bm8wwHEx4TFae+ta2/puy4KmKDFv3jxJUnZ2dp3jeXl5mjBhQusHBAAAAKDNKT98WJIUm9DJ1jiAH7Isq00vobBT0BQljDF2hwAAAACgjaudKUFRAvDN0aNHtWPHDu/7oqIiFRYWKjExUWlpafruu++0e/du7du3T5K0detWSVJycrKSk5Ob3R/bzAIAAAAIGbVFiTiKEoBP1q9fr6ysLGVlZUmScnNzlZWVpSeeeEKStGTJEmVlZenqq6+WJI0dO1ZZWVl6+eWXfeovaGZKAAAAAMCplHtnSnS2NxAgSGVnZze6UmHChAl+3UKBmRIAAAAAQkZF6SFJUmynTvYGAqBJKEoAAAAACBkVxze6ZPkGEBwoSgAAAAAIGWx0CQQXihIAAAAAQoK7xqWq8qOSKEoAwYKiBAAAAICQUFFaKkmyHA7FdIi3ORoATcHTNwAAAAC0mhV/fl27CgsCcu0al1PSsVkSloN/fwWCAUUJAAAAAK3CVV2l9X9/J+D9JKVnBLwPAP5BUQIAAABAq3BVVXn/fMMvn5JlWX7vw7IsJZ/e2+/XBRAYFCUAAAAAtArn8aJEeFSU0vufZ28wANoEFloBAAAAaBWu6mNFiYioaJsjAdBWUJQAAAAA0CpcVZWSpMhoihJAW7Vy5UqNGjVKqampsixLixcv9p5zuVx6+OGH1b9/f8XFxSk1NVW333679u3b53N/FCUAAAAAtApXVbUkZkoAbVl5ebkyMzM1d+7ck85VVFRow4YNevzxx7Vhwwa988472rZtm6699lqf+2NPCQAAAACtwll9bKZEBDMlgDYrJydHOTk59Z5LSEjQsmXL6hx78cUXdeGFF2r37t1KS0trdn8UJQAAAAC0ipoq9pRA+2SMkamstKVvKyYmIE+6qVVaWirLstSpUyefPk9RAgAAAECrqH36RkR0jM2RAK3LVFZq6/kDbOm7z4YCWbGxAbl2VVWVHnnkEd16663q2LGjT9dgTwkAAAAAraL26RtsdAkEP5fLpbFjx8rj8eill17y+TrMlAAAAADQKlws30A7ZcXEqM+GAtv69jeXy6WbbrpJRUVF+uijj3yeJSFRlAAAAADQSmpnSrDRJdoby7ICtoSitdUWJLZv367ly5erS5cuLboeRQkAAAAAreL7PSUoSgBt1dGjR7Vjxw7v+6KiIhUWFioxMVGpqam64YYbtGHDBr333ntyu90qLi6WJCUmJioyMrLZ/VGUAAAAANAqaqpZvgG0devXr9ewYcO873NzcyVJ48eP1/Tp07VkyRJJ0nnnnVfnc8uXL1d2dnaz+6MoAQAAAKBVOKuOPRKRmRJA25WdnS1jTIPnGzvnC56+AQAAAKBVuKqrJUmRPBIUwHEUJQAAAAC0ClftTImoKJsjAdBWUJQAAAAA0CpcVcdmSkQwUwLAcRQlAAAAALQKVzV7SgCoi6IEAAAAgFbhquLpGwDqoigBAAAAoFU4jxclIpkpAeA4ihIAAAAAAs4YI1c1MyUA1EVRAgAAAEDAuV0uGY9HEhtdAvgeRQkAAAAAAVc7S0KSIqJ5JCiAY8LtDgAAAABoicPfFGv1X9+Qs7LS7lDQiBrnsceBhkdEyuEIszkaAG0FRQkAAAAEtU3/WqotHy+3Oww0UXzXbnaHAKARK1eu1PPPP6+CggLt379fixYt0ujRo73np0+froULF2rPnj2KjIzUgAED9PTTT2vQoEE+9RdURYlT3RwAAAC0P67qY/8Cn5F1gc644CKbo8Gp9Ozb3+4QADSivLxcmZmZmjhxoq6//vqTzvfu3Vtz587VaaedpsrKSv3Xf/2Xhg8frh07dqhbt+YXHYOqKHGqmwMAAID2x13jkiSlnNFH51450uZoACC45eTkKCcnp8Hzt956a533s2fP1muvvaaNGzfqiiuuaHZ/QVWUONXNAQAAQPvjrqmRJDnC2KcAQNtkjFGN02NL3+GRDlmWFZBrO51Ovfrqq0pISFBmZqZP1wiqokRzVVdXq/r4dD5JKisrszEaAGgZchqAUOOvvOY5XpQICw/pH20BBLEap0ev/myFLX3f/cJQRUT5t2j73nvvaezYsaqoqFBKSoqWLVumrl27+nStkH4k6KxZs5SQkOB99ezZ0+6QAMBn5DQAocZfec3tdkuSHOER/gwPANCAYcOGqbCwUKtXr9bIkSN10003qaSkxKdrhXQ5edq0acrNzfW+Lysr44d4AEGLnAYg1Pgrr3mO7ynBTAkAbVV4pEN3vzDUtr79LS4uTmeccYbOOOMMXXTRRTrzzDP12muvadq0ac2Pz+/RtSFRUVGKioqyOwwA8AtyGoBQ46+85mb5BoA2zrIsvy+haEuMMXWW4zUHmRsAAABBzbvRJUUJAGixo0ePaseOHd73RUVFKiwsVGJiorp06aKnn35a1157rVJSUnTw4EG99NJL2rt3r2688Uaf+guqzN3YzUlLS7MxMgAAANjF42amBAD4y/r16zVs2DDv+9plduPHj9fLL7+sL774QgsWLNCBAwfUpUsXDRw4UB9//LH69u3rU39Blbkbuznz58+3KSoAAADYiZkSAOA/2dnZMsY0eP6dd97xa39BlblPdXMAAADQ/vBIUAAIXiH9SFAAAACEPu9MiTCKEgAQbChKAAAAIKgxUwIAghdFCQAAAAQ1NxtdAkDQoigBAACAoOb2zpSIsDkSAEBzUZQAAABAUPN495QIszkSAEBzUZQAAABAUPPwSFAACFoUJQAAABDUWL4BAMGLogQAAACCmpunbwBA0KIoAQAAgKBljJGHp28AQNCiKAEAAICg5XG7vX92hFGUAICWWrlypUaNGqXU1FRZlqXFixc32Paee+6RZVmaM2eOz/1RlAAAAEDQqt3kUmKmBAD4Q3l5uTIzMzV37txG2y1evFhr165Vampqi/ojcwMAACBouX9QlODpGwDQcjk5OcrJyWm0zddff63Jkyfrgw8+0NVXX92i/sjcAAAACFruGpf3z46wMBsjAYCGGWNUU11tS9/hUVGyLMtv1/N4PBo3bpwefPBB9e3bt8XXoygBAACAoFW7p4QjLNyvP3QDgD/VVFfrd+NvsKXvqQv+WxHR0X673rPPPqvw8HBNnTrVL9ejKAEAAICgxeNAAaD1FBQU6IUXXtCGDRv8VggmewMAACBo1S7foCgBoC0Lj4rS1AX/bVvf/vLxxx+rpKREaWlp3mNut1sPPPCA5syZo127djU/Pr9FBwAAALSy2qdvsMklgLbMsiy/LqGwy7hx43TllVfWOTZixAiNGzdOEydO9OmaZG8AAAAELe+eEhQlAMAvjh49qh07dnjfFxUVqbCwUImJiUpLS1OXLl3qtI+IiFBycrL69OnjU39kbwAAAAQtlm8AgH+tX79ew4YN877Pzc2VJI0fP17z58/3e39kbwAAAAQt70aXYfxYCwD+kJ2dLWNMk9v7so/EDzla9GkAAADARjx9AwCCG0UJAAAABC2Pm40uASCYUZQAAABA0HLz9A0ACGoUJQAAABC0PCzfAICgRlECAAAAQev7PSUibI4EAOALihIAAAAIWsyUgJ2MMdo7Zaq29OuvLf36q3ztv+0OCQg6ZG8AAAAELe+eEmFhNkeC9qj6iy90ZNmy7w804zGKAI5hpgQAAACC1vcbXbJ8A62vdMnfJUkxFwzQGSvyFXN+ls0RAcGHmRIAAAAIWp4alySWb7RV5WvW6Jtnn5NxOu0OJSBcX38tSeoycaIiune3ORogOJG9AQAAELTcbrckihKtwblnj1x79jS5vXG5tO+RaXIfOhTAqOwX3r27Olx6qd1hAEGL7A0AAICg5WFPCb+qWLdOFQUFJx13ffONDr/9F8njafY1o846S92nTZMsf0QYWE6n0c4dLjmdUkyspd69T70sKOqMM2RFRrZCdEDrWLlypZ5//nkVFBRo//79WrRokUaPHu09P2HCBC1YsKDOZwYNGqQ1a9b41B9FCQAAAAQtHgn6PU9FhZy7d8u1b/8p27r27lXFun/L1Li//3xlpSpO8UtF5Omny2rGrBRHhw5K+fWvFXVaRpM/4wtnVY2Kd5bK7W7aRpOeGo/2bj2ko4eq6xw/sOeIjh46ttSka88OyvqPC/0eK9DWlZeXKzMzUxMnTtT1119fb5uRI0cqLy/P+z6yBYU5ihIAAAAIWu7je0o4QmD5hjFGNd98I7nd9ZyTqj77TFWbN8tUV8njdMpUVavm229V802xXN+UyFNW5pc44n/8Y4V1Sqh70HKoQ/ZQxV9+uV/6cLs8+urzg9q+/hvt235YxtOyp1ZUV9bIU+OfJ1/Ed4lWz7M6q0NitF+uBwSbnJwc5eTkNNomKipKycnJfukv+LM3AAAA2i1PEO0p4T5yROVr1kjHZ3f8kHF79N2f/qiq/9vYoj4cCQmK7NlTCmv8IXuO2Fh1uOQSORLqFh+izzpbMf37tSiGWke+q9I3RWWqPOLU7s3fqcZ57GtljPTt7iNyVp58H1qiY9doxcQ3/V9rE1Pi1D2joyzr+3Ul4ZEO9Tq3qyKj2/7fJwQXY4yMq/nLn/zBinDU+XvuD/n5+UpKSlKnTp00dOhQPf3000pKSvLpWkH33fbSSy/p+eef1/79+9W3b1/NmTNHl7KxDAAAQLvkfSRomD0/1h5ZvlwVa/996obGqGzp0mMzIRoTFiYrov6lKOHduiluyCUK69BBVkSkrKgohXftqvDk7opITlZ49+4K69BBNU63jnxXJdOEiQMnNqmUVLm//KR2bpdHe774ThVlJz9Fo7qiRns+Pyhndd0ZHq6qk2d8ePs1LkXHViq9X1f1OKuzImNa9vULC7fUITFaDodDnbqnNHuPkW+KdmrrJx/LU1OjfV/U3+b8q65Tx67dWhQn2i/j8mjfE6tt6Tv1VxfLivTfvjs5OTm68cYblZ6erqKiIj3++OO6/PLLVVBQoKioqGZfL6iKEm+//bbuv/9+vfTSS7rkkkv0yiuvKCcnR5s3b1ZaWprd4QEAAKCV2flI0JpDh7R36s8kl6ve80ZSdVQn1YTHHj8SprBe5yqie/1TnsO7dVPif9ym8G7d5K7x6FBxhb7bXy7X8V/2a5zlclaWynKEKyquixyOMKlG0l5Ju2tUXLRFh/aXq6bGc3K1IYCMqZbH9ZWMqb0PRsZdIo/7W0VEOuQIsxQVEy5HuKP2Ayo7sFelh6u1cZ+08UP/xhPTMUGdU37UnAGoeOc276ybhpw9JJuiBCDp5ptv9v65X79+uuCCC5Senq73339fY8aMafb1gqooMXv2bN1555266667JElz5szRBx98oHnz5mnWrFk2RwcAAIDW9v1Gl03/sdZ4jFzVblVX1qi63KnKcqeqy6tVXeFSdUW1qiqccrvcqnE65XZWq8ZZLXdNjWpcTjkrq1RdXiVnVZWcZeVyZY2TcYRLJ02N9si4S2VUc7zPChnPkWOnXKUy7sOSTpjKvadImtXYrIsTp343vkTD76z6H6BhjFFDVRDn8RUaVUdOPhcZE+P3GS41Lqcqy0pVWVba7M+edv5AdemZ3uD52IROLYgM7Z0V4VDqry62re9ASklJUXp6urZv3+7T54OmKOF0OlVQUKBHHnmkzvHhw4dr9erATIMpO3xYn67+V0CujVOLkOSwIvy+/qm1WBFRshyWYiMj5HDUkwjCrbprGCPC6/w8ExkWLSs6WpZlKdoRdaxtVHTQ3o9WExGtZj1zLMKhyMjIFt3XmIiwoPm6kNfsE6Fjv7NYCu68FhcdWX9Ok+rktRNzmvR9XosJ+0EuI6+dWnPy2vF1wxERvv89C6acVllRoZ2b1kuSCv71F31e+J4kj4wx8ng8Mqb2l3hT5/8b1T3ebGGS4iRHnNT8icq1fHtaiEMOmeP/15DI6mollh1olSdwGmNJshQVE6vIuBjv8fDIaHVITJTlqH/KeER0lKLjE+op5jRPTcceciZlet973DX6bu9euaqrG/nU9yyHFBUmxcR3UGLPnmrse63kwNcqOfB1nWNRjihZMdGKCY8Jmu+bNqGZeS0UflazLMuvSyjakoMHD2rPnj1KSUnx6fNBU5Q4cOCA3G63unfvXud49+7dVVxcXO9nqqurVf2DhFTWzB2JP139L61fkHfqhkAjhm/6Uo4GdpT+4dETJ346JY17IEzVkZau23Wdwk3QfLsGnT9Xna8a+f4fic2/GqHYyMB/fVqa0yTyGlqusZwmfZ/X6pvMXpvXRu4bTU4LsJbktdbKaVLL89q2Lz6V62h3SWWqLh0kd/V5/g0wSLkknbwrRIBVHn/90L7W6vzwCe87NfmTQ1f+XGGeY/tknLxbxqmR11pHsPysFiqOHj2qHTt2eN8XFRWpsLBQiYmJSkxM1PTp03X99dcrJSVFu3bt0qOPPqquXbvqJz/5iU/9tfKcr5Y7scJljGmw6jVr1iwlJCR4Xz179myNEAEgIMhpAEKNP/KaIzxFjogzZIV18n+AANAOrV+/XllZWcrKypIk5ebmKisrS0888YTCwsK0adMmXXfdderdu7fGjx+v3r1765NPPlF8fLxP/VnGNGVfXvs5nU7Fxsbqr3/9a50KzM9+9jMVFhZqxYoVJ32mvup7z549VVpaqo4dO56yT6Y524vlGyzf8EkbX75RVlamhISEJuehH2ppTpPIa3Zi+QbLN3zWxpdv2JnXKisqtO2LT5vVZ6ib8Y1LmyqNpnYJ12Xxgf/3R8uy73s4Kf8hRR74TAcufERVaZf5dA1HuBQd4VCzfnb4AZZv+KgNL99oSU77oaqqKhUVFSkjI0PR0dE+XycUnOpetGgOi9PpVElJiTyeupvuBOJJGJGRkRowYICWLVtWpyixbNkyXXfddfV+JioqyqdHktTq2KmThl51vc+fBwB/amlOk8hrANqWlua1mNhYZZ5/iR8jCn6xG7/UkYNl6tq7pzJTutgdTmBt+5F0eJ06J0VL551vdzQAfORTUWL79u264447TtpgsnYphfsUj9PxVW5ursaNG6cLLrhAgwcP1quvvqrdu3fr3nvvDUh/AAAAQDCJPP6vwa5G9n4JGR2Sjv1veYm9cQBoEZ+KEhMmTFB4eLjee+89paSktNpUpZtvvlkHDx7Ur371K+3fv1/9+vXTP/7xD6WnN/zoHgAAAKC9CHcc+7ncGRwrtFsm7nhR4ihFCSCY+VSUKCwsVEFBgc466yx/x3NK9913n+67775W7xcAAABo69rXTIlux/63/Ft74wDQIj7tfnPOOefowIED/o4FAAAAQAtEHJ8pUcNMCQBBoslFibKyMu/r2Wef1UMPPaT8/HwdPHiwzrnmPl8aAAAAgH9EHJ8p4WwXMyUoSgChoMnLNzp16lRn7whjjK644oo6bQK90SUAAACAhtUWJVztYabEDze6NEYnPYcYQFBoclFi+fLlko49T3rmzJm65ZZbbNlTAgAAAED9apdvtIuZErXLN9xOqapUiulkazgAfNPkosTQoUO9f77tttt0+eWX68wzzwxIUAAAAACar3ajy3axp0REtBTVUaouO7bZJUUJICj59PSN22+/Xa+99pqeeeYZf8cDAAAAwEcR7emRoJIU1+1YUeJPY44VKZqjQ3dpwnuBiQtAk/lUlHA6nfrDH/6gZcuW6YILLlBcXFyd87Nnz/ZLcAAAAACazrunhMdjcyStJOVc6budUunu5n/WWeH/eIAQsHLlSj3//PMqKCjQ/v37tWjRIo0ePbpOmy1btujhhx/WihUr5PF41LdvX/3lL39RWlpas/vzqSjx2Wef6fzzz5ckbdu2rc45iw1mAAAAAFtEOI49XK/dzJT4ySvSoHsljw8b7YdH+T8eIASUl5crMzNTEydO1PXXX3/S+Z07d2rIkCG68847NWPGDCUkJGjLli2Kjm7mbKXjfCpK1G56CQAAAKDt8O4p0R42upSOFRbSLrI7CiCk5OTkKCcnp8Hzjz32mK666io999xz3mOnnXaaz/05fP4kAAAAgDal3e0pAQQJY4ycTqctL+PHfODxePT++++rd+/eGjFihJKSkjRo0CAtXrzY52v6NFMCAAAAQNvz/Z4SFCWAtsTlcmnmzJm29P3oo48qMjLSL9cqKSnR0aNH9cwzz+ipp57Ss88+q6VLl2rMmDFavnx5nad2NhVFCQAAACBE1M6UcDFTAkAAeI5vonvdddfp5z//uSTpvPPO0+rVq/Xyyy9TlAAAAADas9o9JZzMlADalIiICD366KO29e0vXbt2VXh4uM4555w6x88++2ytWrXKp2tSlAAAAABCRO1MiRpmSgBtimVZfltCYafIyEgNHDhQW7durXN827ZtSk9P9+maFCUAAACAEBHBTAkALXT06FHt2LHD+76oqEiFhYVKTExUWlqaHnzwQd1888267LLLNGzYMC1dulR///vflZ+f71N/FCUAAACAEOHd6JKZEgB8tH79eg0bNsz7Pjc3V5I0fvx4zZ8/Xz/5yU/08ssva9asWZo6dar69Omjv/3tbxoyZIhP/VGUAAAAAEKE95GgzJQA4KPs7OxTPkb0jjvu0B133OGX/hx+uQoAAAAA29VudMmeEgCCBUUJAAAAIESE186UMB6bIwGApqEoAQAAAISI2pkSLpZvAAgSFCUAAACAEBHhOPbjPRtdAggWFCUAAACAEBHBTAkAQYaiBAAAABAiap++wUwJAMGCogQAAAAQImr3lOCRoACCBUUJAAAAIETUzpTwSHIzWwJAEKAoAQAAAISI2j0lJPaVABAcKEoAAAAAIaJOUYKZEgCCAEUJAAAAIETULt+Q2FcCgG9WrlypUaNGKTU1VZZlafHixXXOW5ZV7+v555/3qT+KEgAAAECICLMshR2vSzBTAoAvysvLlZmZqblz59Z7fv/+/XVer7/+uizL0vXXX+9Tf+EtCRYAAABA2xJhWXIbI6fHY3coAIJQTk6OcnJyGjyfnJxc5/27776rYcOG6bTTTvOpP4oSAAAAQAiJsCxVyaiGiRJAm2GMkcdTaUvfDkeMrB/sN+NP33zzjd5//30tWLDA52tQlAAAAABCSITDktyS0zBTAmgrPJ5K5a/ob0vf2UM3KSwsNiDXXrBggeLj4zVmzBifr8GeEgAAAEAIibSO/YjPI0EBBNrrr7+u2267TdHR0T5fg5kSAAAAQAgJP/7PjhQlgLbD4YhR9tBNtvUdCB9//LG2bt2qt99+u0XXoSgBAAAAhBDvTAmevgG0GZZlBWwJhV1ee+01DRgwQJmZmS26TtAs33j66ad18cUXKzY2Vp06dbI7HAAAAKBNinAc29COogQAXxw9elSFhYUqLCyUJBUVFamwsFC7d+/2tikrK9Nf//pX3XXXXS3uL2iKEk6nUzfeeKP+8z//0+5QAAAAgDYr8vgu+06WbwDwwfr165WVlaWsrCxJUm5urrKysvTEE0942yxcuFDGGN1yyy0t7i9olm/MmDFDkjR//nx7AwEAAADasHCLmRIAfJednS1zivxx99136+677/ZLf0FTlPBFdXW1qqurve/LyspsjAYAWoacBiDUkNcCI7J2+QYzJQAEgaBZvuGLWbNmKSEhwfvq2bOn3SEBgM/IaQBCDXktMCKYKQEgiNhalJg+fbosy2r0tX79ep+vP23aNJWWlnpfe/bs8WP0ANC6yGkAQg15LTBqN7pkTwkAwcDW5RuTJ0/W2LFjG23Tq1cvn68fFRWlqKgonz8PAG0JOQ1AqCGvBQYzJQAEE1uLEl27dlXXrl3tDAEAAAAIKbUzJYqrXfqqsvoUrZtwPctSanRki68DAPUJmo0ud+/ere+++067d++W2+32PjP1jDPOUIcOHewNDgAAAGgjah8J+ptdxfrNrmK/XPPBXsl6ICPZL9cCgB8KmqLEE088oQULFnjf1z4zdfny5crOzrYpKgAAAKBtubpbJ604dETVfthTosYYVXuMCo9U+CEyADhZ0BQl5s+fr/nz59sdBgAAANCmXZPUSdckdfLLtf67+DtN3rKbx4sCCJiQfiQoAAAAAN+FH18K4mTTTAABQlECAAAAQL0ij2+aWUNRAkCAUJQAAAAAUK/ax4s6Wb4BtBsrV67UqFGjlJqaKsuytHjx4jrnjx49qsmTJ6tHjx6KiYnR2WefrXnz5vncH0UJAAAAAPWKdBz7dcFlPDZHAqC1lJeXKzMzU3Pnzq33/M9//nMtXbpUf/7zn7Vlyxb9/Oc/15QpU/Tuu+/61F/QbHQJAAAAoHWFH5sowUwJoB3JyclRTk5Og+c/+eQTjR8/3vsUzLvvvluvvPKK1q9fr+uuu67Z/VGUAAAAAFCv72dKUJQAWsIYowqPPTOOYh0OWceXYvnDkCFDtGTJEt1xxx1KTU1Vfn6+tm3bphdeeMGn61GUAAAAAFCv2j0leCQo0DIVHo9OX7nJlr53XtZfcWFhfrve7373O/30pz9Vjx49FB4eLofDoT/84Q8aMmSIT9ejKAEAAACgXrVP32CmBIBav/vd77RmzRotWbJE6enpWrlype677z6lpKToyiuvbPb1KEoAAAAAqFc4MyUAv4h1OLTzsv629e0vlZWVevTRR7Vo0SJdffXVkqRzzz1XhYWF+s1vfkNRAgAAAID/1M6UcDJTAmgRy7L8uoTCLi6XSy6XS44TCh1hYWHy+LhnBkUJAAAAAPWq3VOihqIE0G4cPXpUO3bs8L4vKipSYWGhEhMTlZaWpqFDh+rBBx9UTEyM0tPTtWLFCv3xj3/U7NmzfeqPogQAAACAenlnSniMjDF+3cEfQNu0fv16DRs2zPs+NzdXkjR+/HjNnz9fCxcu1LRp03Tbbbfpu+++U3p6up5++mnde++9PvVHUQIAAABAvWpnShhJbiOFU5MAQl52drZMI7OjkpOTlZeX57f+/LfjBQAAAICQEvGDmRHsKwEgEChKAAAAAKhXhOP7ogT7SgAIBIoSAAAAAOpVZ6YEjwUFEAAUJQAAAADUy7Isb2HCZXx73B8ANIaiBAAAAIAGhVvfP4EDAPyNogQAAACABtU+FpQ9JQAEAkUJAAAAAA2KYKYEgACiKAEAAACgQbUzJVzMlAAQABQlAAAAADSodk8JFzMlAAQARQkAAAAADaqdKeFkpgSAAKAoAQAAAKBBtXtK1DBTAmgXVq5cqVGjRik1NVWWZWnx4sV1zn/zzTeaMGGCUlNTFRsbq5EjR2r79u0+90dRAgAAAECDIpgpAbQr5eXlyszM1Ny5c086Z4zR6NGj9eWXX+rdd9/Vp59+qvT0dF155ZUqLy/3qb/wlgYMAAAAIHRFsKcE0K7k5OQoJyen3nPbt2/XmjVr9Nlnn6lv376SpJdeeklJSUl66623dNdddzW7P4oSAAAAABrkfSQoMyUAnxljVOly29J3TESYrOPfxy1VXV0tSYqOjvYeCwsLU2RkpFatWkVRAgAAAIB/1W50WUNRAvBZpcutc574wJa+N/9qhGIj/fOr/1lnnaX09HRNmzZNr7zyiuLi4jR79mwVFxdr//79Pl2TPSUAAAAANCjCOvYrg9PjsTkSAHaLiIjQ3/72N23btk2JiYmKjY1Vfn6+cnJyFBYW5tM1mSkBAAAAoEG1MyVczJQAfBYTEabNvxphW9/+NGDAABUWFqq0tFROp1PdunXToEGDdMEFF/h0PYoSAAAAABoUXrunBBtdAj6zLMtvSyjaioSEBEnHNr9cv369fv3rX/t0ndC6KwAAAAD8ij0lgPbl6NGj2rFjh/d9UVGRCgsLlZiYqLS0NP31r39Vt27dlJaWpk2bNulnP/uZRo8ereHDh/vUH0UJAAAAAA2KYKYE0K6sX79ew4YN877Pzc2VJI0fP17z58/X/v37lZubq2+++UYpKSm6/fbb9fjjj/vcH0UJAAAAAA1iTwmgfcnOzpZp5Pt96tSpmjp1qt/6C4qnb+zatUt33nmnMjIyFBMTo9NPP11PPvmknE6n3aEBAAAAIa12TwkXMyUABEBQzJT44osv5PF49Morr+iMM87QZ599pp/+9KcqLy/Xb37zG7vDAwAAAEJWBDMlAARQUBQlRo4cqZEjR3rfn3baadq6davmzZtHUQIAAAAIoEhmSgAIoKAoStSntLRUiYmJjbaprq5WdXW1931ZWVmgwwKAgCGnAQg15LXgUDtTwslMCQABEBR7Spxo586devHFF3Xvvfc22m7WrFlKSEjwvnr27NlKEQKA/5HTAIQa8lpwiGCmBIAAsrUoMX36dFmW1ehr/fr1dT6zb98+jRw5UjfeeKPuuuuuRq8/bdo0lZaWel979uwJ5HAAIKDIaQBCDXktOHgfCWo8NkcCIBTZunxj8uTJGjt2bKNtevXq5f3zvn37NGzYMA0ePFivvvrqKa8fFRWlqKioloYJAG0COQ1AqCGvBYfaR4LWMFECQADYWpTo2rWrunbt2qS2X3/9tYYNG6YBAwYoLy9PDkdQrjwBAAAAgkrE8Z+7nR5mSgDwv6DY6HLfvn3Kzs5WWlqafvOb3+jbb7/1nktOTrYxMgAAACC0efeUYKNLAAEQFEWJDz/8UDt27NCOHTvUo0ePOucMyREAAAAIGO+eEmx0CSAAgmINxIQJE2SMqfcFAAAAIHC+31OCn72BUDdr1iwNHDhQ8fHxSkpK0ujRo7V169Y6bYwxmj59ulJTUxUTE6Ps7Gx9/vnnPvcZFEUJAAAAAPbgkaBA+7FixQpNmjRJa9as0bJly1RTU6Phw4ervLzc2+a5557T7NmzNXfuXK1bt07Jycn68Y9/rCNHjvjUZ1As3wAAAABgj9qZEk5mSgAhb+nSpXXe5+XlKSkpSQUFBbrssstkjNGcOXP02GOPacyYMZKkBQsWqHv37nrzzTd1zz33NLtPihIAAAAAGhR+fKbEZ0cqNXjNZu/x3/ftpX7xsXaFBQQXYyRXhT19R8RKx7+Pm6u0tFSSlJiYKEkqKipScXGxhg8f7m0TFRWloUOHavXq1RQlAAAAAPjXabFRcujYTImiSqf3OBtfAs3gqpBmptrT96P7pMi4Zn/MGKPc3FwNGTJE/fr1kyQVFxdLkrp3716nbffu3fXVV1/5FB5FCQAAAAAN6hUTpXWDz9G+aled473jom2KCEBrmDx5sjZu3KhVq1addM46YeaFMeakY01FUQIAAABAo34UHakfRUfaHQYQvCJij81YsKvvZpoyZYqWLFmilStXqkePHt7jycnJko7NmEhJSfEeLykpOWn2RFNRlAAAAAAAIJAsy6clFK3NGKMpU6Zo0aJFys/PV0ZGRp3zGRkZSk5O1rJly5SVlSVJcjqdWrFihZ599lmf+qQoAQAAAAAANGnSJL355pt69913FR8f791DIiEhQTExMbIsS/fff79mzpypM888U2eeeaZmzpyp2NhY3XrrrT71SVECAAAAAABo3rx5kqTs7Ow6x/Py8jRhwgRJ0kMPPaTKykrdd999OnTokAYNGqQPP/xQ8fHxPvVJUQIAAAAAAMiYUz9Vx7IsTZ8+XdOnT/dLnw6/XAUAAAAAAKCZKEoAAAAAAABbtKvlG7VTUcrKymyOBEB7VZt/mjI17lTIaQDaAvIagFDiz5yGpmlXRYkjR45Iknr27GlzJADauyNHjighIaHF15DIaQDaBvIagFDij5yGpmlXRYnU1FTt2bNH8fHxsiyrSZ8pKytTz549tWfPHnXs2DHAEdoj1McY6uOTQn+MoTQ+Y4yOHDmi1NTUFl/Ll5wmhdb9rE+oj08K/TGG+vik0Bqj3XktlO5lQxhj8Av18UmhM0Z/5jQ0TbsqSjgcDvXo0cOnz3bs2DGov7maItTHGOrjk0J/jKEyPn9V3VuS06TQuZ8NCfXxSaE/xlAfnxQ6Y2wLeS1U7mVjGGPwC/XxSaExRmZItC42ugQAAAAAALagKAEAAAAAAGxBUeIUoqKi9OSTTyoqKsruUAIm1McY6uOTQn+MoT6+1hbq9zPUxyeF/hhDfXxS+xhja2kP95IxBr9QH5/UPsaIwLAMzzoBAAAAAMBvqqqqVFRUpIyMDEVHR9sdjq1OdS+YKQEAAAAAADRr1iwNHDhQ8fHxSkpK0ujRo7V169Y6bd555x2NGDFCXbt2lWVZKiwsbFGfFCUAAAAAAIBWrFihSZMmac2aNVq2bJlqamo0fPhwlZeXe9uUl5frkksu0TPPPOOXPtvVI0EBAAAAAED9li5dWud9Xl6ekpKSVFBQoMsuu0ySNG7cOEnSrl27/NInRQkAAAAAAALIGKPKmkpb+o4Jj5FlWT59trS0VJKUmJjoz5DqYPlGI1566SXvZhwDBgzQxx9/bHdI9Zo+fbosy6rzSk5O9p43xmj69OlKTU1VTEyMsrOz9fnnn9e5RnV1taZMmaKuXbsqLi5O1157rfbu3VunzaFDhzRu3DglJCQoISFB48aN0+HDhwMyppUrV2rUqFFKTU2VZVlavHhxnfOtOabdu3dr1KhRiouLU9euXTV16lQ5nc6Ajm/ChAknfU0vuuiioBlfU9aiBfvXMFiR1+zJa6Ge05oyRvJa2x9jsAqGvBZqOU0ir0nktWAYY1tSWVOpQW8OsuXlazHEGKPc3FwNGTJE/fr18/Md+R5FiQa8/fbbuv/++/XYY4/p008/1aWXXqqcnBzt3r3b7tDq1bdvX+3fv9/72rRpk/fcc889p9mzZ2vu3Llat26dkpOT9eMf/1hHjhzxtrn//vu1aNEiLVy4UKtWrdLRo0d1zTXXyO12e9vceuutKiws1NKlS7V06VIVFhZ6p+74W3l5uTIzMzV37tx6z7fWmNxut66++mqVl5dr1apVWrhwof72t7/pgQceCOj4JGnkyJF1vqb/+Mc/6pxvy+Nrylq0YP8aBiPymn15LdRzWlPGKJHX2voYg1Ew5bVQymkSea0Wea1tjxEtM3nyZG3cuFFvvfVWYDsyqNeFF15o7r333jrHzjrrLPPII4/YFFHDnnzySZOZmVnvOY/HY5KTk80zzzzjPVZVVWUSEhLMyy+/bIwx5vDhwyYiIsIsXLjQ2+brr782DofDLF261BhjzObNm40ks2bNGm+bTz75xEgyX3zxRQBG9T1JZtGiRbaM6R//+IdxOBzm66+/9rZ56623TFRUlCktLQ3I+IwxZvz48ea6665r8DPBND5jjCkpKTGSzIoVK4wxofc1DBbktbaR10I9p9U3RmPIa8E4xmAQLHktlHOaMeS1hgTbGMlr/lVZWWk2b95sKisrjTHH7me5s9yWl8fjaXb8kydPNj169DBffvllg22KioqMJPPpp582616ciJkS9XA6nSooKNDw4cPrHB8+fLhWr15tU1SN2759u1JTU5WRkaGxY8fqyy+/lCQVFRWpuLi4zliioqI0dOhQ71gKCgrkcrnqtElNTVW/fv28bT755BMlJCRo0KBB3jYXXXSREhISWv2etOaYPvnkE/Xr10+pqaneNiNGjFB1dbUKCgoCOs78/HwlJSWpd+/e+ulPf6qSkhLvuWAb34lr0drL17AtIa+13bzWnr4fyGvBNca2LtjyWnvJaVL7+n4grwXXGO1kWZZiI2JteTVnPwljjCZPnqx33nlHH330kTIyMgJ4V46hKFGPAwcOyO12q3v37nWOd+/eXcXFxTZF1bBBgwbpj3/8oz744AP9/ve/V3FxsS6++GIdPHjQG29jYykuLlZkZKQ6d+7caJukpKST+k5KSmr1e9KaYyouLj6pn86dOysyMjKg487JydEbb7yhjz76SL/97W+1bt06XX755aqurvbGFSzjM/WsRWsPX8O2hrxWf5u2kNfay/cDeS24xhgMgimvtaecVhtLbXw/FGrfD+S14BojmmbSpEn685//rDfffFPx8fEqLi5WcXGxKiu/35fiu+++U2FhoTZv3ixJ2rp1qwoLC33+WvH0jUacWFEyxvi8a2kg5eTkeP/cv39/DR48WKeffroWLFjg3WzHl7Gc2Ka+9nbek9Yakx3jvvnmm71/7tevny644AKlp6fr/fff15gxYxr8XFscX+1atFWrVp10LpS/hm0Vea3t/t0I9e8H8lrD2uIYg0kw5LX2mNOk0P9+IK81rC2OEU0zb948SVJ2dnad43l5eZowYYIkacmSJZo4caL33NixYyVJTz75pKZPn97sPpkpUY+uXbsqLCzspEpPSUnJSRW8tiguLk79+/fX9u3bvTs7NzaW5ORkOZ1OHTp0qNE233zzzUl9ffvtt61+T1pzTMnJySf1c+jQIblcrlYdd0pKitLT07V9+3ZvXMEwvilTpmjJkiVavny5evTo4T3eHr+GdiOv1d+mLeS19vr9QF5ruI3dYwwWwZzXQjmn1cYitb/vB/Jaw23sHiOazhhT76u2ICEde/JMfW18KUhIFCXqFRkZqQEDBmjZsmV1ji9btkwXX3yxTVE1XXV1tbZs2aKUlBRlZGQoOTm5zlicTqdWrFjhHcuAAQMUERFRp83+/fv12WefedsMHjxYpaWl+ve//+1ts3btWpWWlrb6PWnNMQ0ePFifffaZ9u/f723z4YcfKioqSgMGDAjoOH/o4MGD2rNnj1JSUiS1/fGdai1ae/wa2o281nbzWnv9fiCvtb0xBptgzmuhnNOk9vv9QF5re2NEkGh0m8x2bOHChSYiIsK89tprZvPmzeb+++83cXFxZteuXXaHdpIHHnjA5Ofnmy+//NKsWbPGXHPNNSY+Pt4b6zPPPGMSEhLMO++8YzZt2mRuueUWk5KSYsrKyrzXuPfee02PHj3MP//5T7NhwwZz+eWXm8zMTFNTU+NtM3LkSHPuueeaTz75xHzyySemf//+5pprrgnImI4cOWI+/fRT8+mnnxpJZvbs2ebTTz81X331VauOqaamxvTr189cccUVZsOGDeaf//yn6dGjh5k8eXLAxnfkyBHzwAMPmNWrV5uioiKzfPlyM3jwYPOjH/0oaMb3n//5nyYhIcHk5+eb/fv3e18VFRXeNsH+NQxG5DX78lqo57RTjZG8FhxjDEbBktdCLacZQ14jrwXHGO10qidOtCenuhcUJRrx//7f/zPp6ekmMjLSnH/++d7H47Q1N998s0lJSTEREREmNTXVjBkzxnz++efe8x6Pxzz55JMmOTnZREVFmcsuu8xs2rSpzjUqKyvN5MmTTWJioomJiTHXXHON2b17d502Bw8eNLfddpuJj4838fHx5rbbbjOHDh0KyJiWL19uJJ30Gj9+fKuP6auvvjJXX321iYmJMYmJiWby5MmmqqoqYOOrqKgww4cPN926dTMREREmLS3NjB8//qTY2/L46hubJJOXl+dtE+xfw2BFXrMnr4V6TjvVGMlrwTHGYBUMeS3Ucpox5DXyWnCM0U4UJb53qnthGWOMP2deAAAAAADQnlVVVamoqEgZGRmKjo62OxxbnepesKcEAAAAAACwBUUJAAAAAABgC4oSAAAAAADAFhQlAAAAAACALShKAAAAAAAAW1CUAAAAAAAAtqAoAQAAAAAANGvWLA0cOFDx8fFKSkrS6NGjtXXrVu95l8ulhx9+WP3791dcXJxSU1N1++23a9++fT73SVECOC4/P1+WZenw4cN2hwIALUZOAxBqyGtA4K1YsUKTJk3SmjVrtGzZMtXU1Gj48OEqLy+XJFVUVGjDhg16/PHHtWHDBr3zzjvatm2brr32Wp/7tIwxxl8DAIJJdna2zjvvPM2ZM0eS5HQ69d1336l79+6yLMve4ACgmchpAEINeQ3BrKqqSkVFRcrIyFB0dLTd4fjs22+/VVJSklasWKHLLrus3jbr1q3ThRdeqK+++kppaWknnT/VvQj3e9RAkIqMjFRycrLdYQCAX5DTAIQa8hqCmTFGprLSlr6tmBifC3mlpaWSpMTExEbbWJalTp06+dQHyzfQLk2YMEErVqzQCy+8IMuyZFmW5s+fX2dK4Pz589WpUye999576tOnj2JjY3XDDTeovLxcCxYsUK9evdS5c2dNmTJFbrfbe22n06mHHnpIP/rRjxQXF6dBgwYpPz/fnoECaBfIaQBCDXkNocZUVmrr+QNseflaDDHGKDc3V0OGDFG/fv3qbVNVVaVHHnlEt956qzp27OhTP8yUQLv0wgsvaNu2berXr59+9atfSZI+//zzk9pVVFTod7/7nRYuXKgjR45ozJgxGjNmjDp16qR//OMf+vLLL3X99ddryJAhuvnmmyVJEydO1K5du7Rw4UKlpqZq0aJFGjlypDZt2qQzzzyzVccJoH0gpwEINeQ1wH6TJ0/Wxo0btWrVqnrPu1wujR07Vh6PRy+99JLP/VCUQLuUkJCgyMhIxcbGeqcBfvHFFye1c7lcmjdvnk4//XRJ0g033KA//elP+uabb9ShQwedc845GjZsmJYvX66bb75ZO3fu1FtvvaW9e/cqNTVVkvSLX/xCS5cuVV5enmbOnNl6gwTQbpDTAIQa8hpCjRUToz4bCmzru7mmTJmiJUuWaOXKlerRo8dJ510ul2666SYVFRXpo48+8nmWhERRAmhUbGys9z9yktS9e3f16tVLHTp0qHOspKREkrRhwwYZY9S7d+8616murlaXLl1aJ2gAaAA5DUCoIa8hWFiWJSs21u4wTskYoylTpmjRokXKz89XRkbGSW1qCxLbt2/X8uXLW/y9Q1ECaERERESd95Zl1XvM4/FIkjwej8LCwlRQUKCwsLA67X74H0cAsAM5DUCoIa8B/jVp0iS9+eabevfddxUfH6/i4mJJx2YvxcTEqKamRjfccIM2bNig9957T26329smMTFRkZGRze6TogTarcjIyDqbHvlDVlaW3G63SkpKdOmll/r12gDQGHIagFBDXgNa37x58yQdeyTvD+Xl5WnChAnau3evlixZIkk677zz6rRZvnz5SZ9rCooSaLd69eqltWvXateuXerQoYO3gt4SvXv31m233abbb79dv/3tb5WVlaUDBw7oo48+Uv/+/XXVVVf5IXIAOBk5DUCoIa8Brc8Y0+j5Xr16nbJNc/FIULRbv/jFLxQWFqZzzjlH3bp10+7du/1y3by8PN1+++164IEH1KdPH1177bVau3atevbs6ZfrA0B9yGkAQg15DWgfLOPvMgcAAAAAAO1YVVWVioqKlJGRoejoaLvDsdWp7gUzJQAAAAAAgC0oSgAAAAAAAFtQlAAAAAAAALagKAEAAAAAAGxBUQIAAAAAANiCogQAAAAAALAFRQkAAAAAAGALihIAAAAAAMAWFCUAAAAAAIBmzZqlgQMHKj4+XklJSRo9erS2bt1ap8306dN11llnKS4uTp07d9aVV16ptWvX+twnRQkAAAAAAKAVK1Zo0qRJWrNmjZYtW6aamhoNHz5c5eXl3ja9e/fW3LlztWnTJq1atUq9evXS8OHD9e233/rUp2WMMf4aAAAAAAAA7V1VVZWKioqUkZGh6Ohou8Px2bfffqukpCStWLFCl112Wb1tysrKlJCQoH/+85+64oorTjp/qnsR7veoAQAAAACAlzFGNU6PLX2HRzpkWZZPny0tLZUkJSYm1nve6XTq1VdfVUJCgjIzM32Lz6dPAQAAAACAJqlxevTqz1bY0vfdLwxVRFRYsz9njFFubq6GDBmifv361Tn33nvvaezYsaqoqFBKSoqWLVumrl27+hQfe0oAAAAAAIA6Jk+erI0bN+qtt9466dywYcNUWFio1atXa+TIkbrppptUUlLiUz/sKQEAAAAAgB+duI9CsC3fmDJlihYvXqyVK1cqIyPjlO3PPPNM3XHHHZo2bdpJ59hTAgAAAAAAG1mW5dMSitZmjNGUKVO0aNEi5efnN6kgUfu56upqn/qkKAEAAAAAADRp0iS9+eabevfddxUfH6/i4mJJUkJCgmJiYlReXq6nn35a1157rVJSUnTw4EG99NJL2rt3r2688Uaf+qQoAQAAAAAANG/ePElSdnZ2neN5eXmaMGGCwsLC9MUXX2jBggU6cOCAunTpooEDB+rjjz9W3759feqTogQAAAAAANCptpyMjo7WO++849c+efoGAAAAAACwBUUJAAAAAABgC4oSAAAAAADAFhQlAAAAAACALShKAAAAAAAAW1CUAAAAAAAAtqAoAQAAAAAAbEFRAgAAAAAA2IKiBAAAAAAAsAVFCQAAAAAAYAuKEgAAAAAAQLNmzdLAgQMVHx+vpKQkjR49Wlu3bm2w/T333CPLsjRnzhyf+6QoAQAAAAAAtGLFCk2aNElr1qzRsmXLVFNTo+HDh6u8vPyktosXL9batWuVmpraoj7DW/RpAAAAAAAQEpYuXVrnfV5enpKSklRQUKDLLrvMe/zrr7/W5MmT9cEHH+jqq69uUZ8UJQAAAAAACCBjjGqqq23pOzwqSpZl+fTZ0tJSSVJiYqL3mMfj0bhx4/Tggw+qb9++LY+vxVcAAAAAAAANqqmu1u/G32BL31MX/LcioqOb/TljjHJzczVkyBD169fPe/zZZ59VeHi4pk6d6pf4KEoAAAAAAIA6Jk+erI0bN2rVqlXeYwUFBXrhhRe0YcMGn2dfnMgyxhi/XAkAAAAAAKiqqkpFRUXKyMhQdHR00C3fmDJlihYvXqyVK1cqIyPDe3zOnDnKzc2Vw/H9MzPcbrccDod69uypXbt2nXStE+/FSfE1KzIAAAAAANAslmX5tISitRljNGXKFC1atEj5+fl1ChKSNG7cOF155ZV1jo0YMULjxo3TxIkTfeqTogQAAAAAANCkSZP05ptv6t1331V8fLyKi4slSQkJCYqJiVGXLl3UpUuXOp+JiIhQcnKy+vTp41OfjlM3AQAAAAAAoW7evHkqLS1Vdna2UlJSvK+33347YH0yUwIAAAAAAMiXLSfr20eiOZgpAQAAAAAAbEFRAgAAAAAA2IKiBAAAAAAAsAVFCQAAAAAAYAuKEgAAAAAABIAvG0eGmlPdA4oSAAAAAAD4UUREhCSpoqLC5kjs53Q6JUlhYWH1nueRoAAAAAAA+FFYWJg6deqkkpISSVJsbKwsy7I5qtbn8Xj07bffKjY2VuHh9ZcfKEoAAAAAAOBnycnJkuQtTLRXDodDaWlpDRZlLMMiFwAAAAAAAsLtdsvlctkdhm0iIyPlcDS8cwRFCQAAAAAAYAs2ugQAAAAAALagKAEAAAAAAGxBUQIAAAAAANiCogQAAAAAALAFRQkAAAAAAGALihIAAAAAAMAWFCUAAAAAAIAt/j9ks5r9Lam6pwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "swiftdiff.sel(id=tpid)['rh'].plot(x=\"time\",hue=\"id\",col=\"space\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "swiftdiff.sel(id=plid)['vh'].plot(x=\"time\",hue=\"id\",col=\"space\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "swiftdiff.sel(id=tpid)['vh'].plot(x=\"time\",hue=\"id\",col=\"space\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (My debug_env Kernel)", + "language": "python", + "name": "debug_env" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_vs_swifter.py b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_vs_swifter.py new file mode 100644 index 000000000..dce7c1358 --- /dev/null +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_vs_swifter.py @@ -0,0 +1,9 @@ +import swiftest +import numpy as np + +swiftersim = swiftest.Simulation(simdir="swifter_sim", read_data=True, codename="Swifter") +swiftestsim = swiftest.Simulation(simdir="swiftest_sim",read_data=True) +swiftestsim.data = swiftestsim.data.swap_dims({"name" : "id"}) +swiftdiff = swiftestsim.data - swiftersim.data +swiftdiff['rh'].plot(x="time",hue="id",col="space") +swiftdiff['vh'].plot(x="time",hue="id",col="space") \ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d2a04991c..a0ae5a554 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -13,17 +13,37 @@ # Add the source files SET(STRICT_MATH_FILES - ${SRC}/swiftest/swiftest_kick.f90 - ${SRC}/helio/helio_kick.f90 - ${SRC}/rmvs/rmvs_kick.f90 - ${SRC}/symba/symba_kick.f90 - ${SRC}/whm/whm_kick.f90 - ${SRC}/swiftest/swiftest_user.f90 + ${SRC}/collision/collision_generate.f90 ${SRC}/fraggle/fraggle_generate.f90 ${SRC}/fraggle/fraggle_util.f90 ${SRC}/fraggle/fraggle_module.f90 + ${SRC}/helio/helio_drift.f90 + ${SRC}/helio/helio_gr.f90 + ${SRC}/helio/helio_kick.f90 + ${SRC}/helio/helio_step.f90 ${SRC}/misc/lambda_function_module.f90 ${SRC}/misc/solver_module.f90 + ${SRC}/operator/operator_module.f90 + ${SRC}/operator/operator_cross.f90 + ${SRC}/operator/operator_mag.f90 + ${SRC}/operator/operator_unit.f90 + ${SRC}/rmvs/rmvs_kick.f90 + ${SRC}/rmvs/rmvs_step.f90 + ${SRC}/swiftest/swiftest_drift.f90 + ${SRC}/swiftest/swiftest_gr.f90 + ${SRC}/swiftest/swiftest_kick.f90 + ${SRC}/swiftest/swiftest_user.f90 + ${SRC}/swiftest/swiftest_obl.f90 + ${SRC}/swiftest/swiftest_orbel.f90 + ${SRC}/symba/symba_drift.f90 + ${SRC}/symba/symba_gr.f90 + ${SRC}/symba/symba_kick.f90 + ${SRC}/symba/symba_step.f90 + ${SRC}/whm/whm_coord.f90 + ${SRC}/whm/whm_drift.f90 + ${SRC}/whm/whm_gr.f90 + ${SRC}/whm/whm_kick.f90 + ${SRC}/whm/whm_step.f90 ) SET(FAST_MATH_FILES @@ -33,7 +53,6 @@ SET(FAST_MATH_FILES ${SRC}/misc/io_progress_bar_module.f90 ${SRC}/encounter/encounter_module.f90 ${SRC}/collision/collision_module.f90 - ${SRC}/operator/operator_module.f90 ${SRC}/walltime/walltime_module.f90 ${SRC}/swiftest/swiftest_module.f90 ${SRC}/whm/whm_module.f90 @@ -41,7 +60,6 @@ SET(FAST_MATH_FILES ${SRC}/helio/helio_module.f90 ${SRC}/symba/symba_module.f90 ${SRC}/collision/collision_check.f90 - ${SRC}/collision/collision_generate.f90 ${SRC}/collision/collision_io.f90 ${SRC}/collision/collision_regime.f90 ${SRC}/collision/collision_resolve.f90 @@ -49,36 +67,18 @@ SET(FAST_MATH_FILES ${SRC}/encounter/encounter_check.f90 ${SRC}/encounter/encounter_io.f90 ${SRC}/encounter/encounter_util.f90 - ${SRC}/helio/helio_drift.f90 - ${SRC}/helio/helio_gr.f90 - ${SRC}/helio/helio_step.f90 ${SRC}/helio/helio_util.f90 ${SRC}/netcdf_io/netcdf_io_implementations.f90 - ${SRC}/operator/operator_cross.f90 - ${SRC}/operator/operator_mag.f90 - ${SRC}/operator/operator_unit.f90 ${SRC}/rmvs/rmvs_discard.f90 ${SRC}/rmvs/rmvs_encounter_check.f90 - ${SRC}/rmvs/rmvs_step.f90 ${SRC}/rmvs/rmvs_util.f90 ${SRC}/swiftest/swiftest_discard.f90 - ${SRC}/swiftest/swiftest_drift.f90 - ${SRC}/swiftest/swiftest_gr.f90 ${SRC}/swiftest/swiftest_io.f90 - ${SRC}/swiftest/swiftest_obl.f90 - ${SRC}/swiftest/swiftest_orbel.f90 ${SRC}/swiftest/swiftest_util.f90 ${SRC}/symba/symba_discard.f90 - ${SRC}/symba/symba_drift.f90 ${SRC}/symba/symba_encounter_check.f90 - ${SRC}/symba/symba_gr.f90 - ${SRC}/symba/symba_step.f90 ${SRC}/symba/symba_util.f90 ${SRC}/walltime/walltime_implementations.f90 - ${SRC}/whm/whm_coord.f90 - ${SRC}/whm/whm_drift.f90 - ${SRC}/whm/whm_gr.f90 - ${SRC}/whm/whm_step.f90 ${SRC}/whm/whm_util.f90 ${SRC}/swiftest/swiftest_driver.f90 ) diff --git a/src/rmvs/rmvs_step.f90 b/src/rmvs/rmvs_step.f90 index bcb38797a..11f7d2756 100644 --- a/src/rmvs/rmvs_step.f90 +++ b/src/rmvs/rmvs_step.f90 @@ -202,6 +202,10 @@ subroutine rmvs_step_out(cb, pl, tp, nbody_system, param, t, dt) call tp%step(nbody_system, param, outer_time, dto) tp%lfirst = lfirsttp else + if (param%loblatecb) then + call swiftest_obl_acc(npl, cb%Gmass, cb%j2rp2, cb%j4rp4, pl%rbeg, pl%lmask, pl%outer(outer_index-1)%aobl, pl%Gmass, cb%aoblbeg) + call swiftest_obl_acc(npl, cb%Gmass, cb%j2rp2, cb%j4rp4, pl%rend, pl%lmask, pl%outer(outer_index)%aobl, pl%Gmass, cb%aoblend) + end if call tp%step(nbody_system, param, outer_time, dto) end if do j = 1, npl diff --git a/src/rmvs/rmvs_util.f90 b/src/rmvs/rmvs_util.f90 index 224ba2cd1..6b26bf12f 100644 --- a/src/rmvs/rmvs_util.f90 +++ b/src/rmvs/rmvs_util.f90 @@ -298,13 +298,15 @@ module subroutine rmvs_util_setup_pl(self, n, param) allocate(pl%outer(i)%v(NDIM, n)) pl%outer(i)%x(:,:) = 0.0_DP pl%outer(i)%v(:,:) = 0.0_DP + allocate(pl%outer(i)%aobl(NDIM, n)) + pl%outer(i)%aobl(:,:) = 0.0_DP end do do i = 0, NTPHENC allocate(pl%inner(i)%x(NDIM, n)) allocate(pl%inner(i)%v(NDIM, n)) - allocate(pl%inner(i)%aobl(NDIM, n)) pl%inner(i)%x(:,:) = 0.0_DP pl%inner(i)%v(:,:) = 0.0_DP + allocate(pl%inner(i)%aobl(NDIM, n)) pl%inner(i)%aobl(:,:) = 0.0_DP end do ! if (param%ltides) then diff --git a/src/swiftest/swiftest_io.f90 b/src/swiftest/swiftest_io.f90 index 8cb720ec0..96f974362 100644 --- a/src/swiftest/swiftest_io.f90 +++ b/src/swiftest/swiftest_io.f90 @@ -983,7 +983,6 @@ module subroutine swiftest_io_netcdf_open(self, param, readonly) ! Optional variables The User Doesn't Need to Know About status = nf90_inq_varid(nc%id, nc%mass_varname, nc%mass_varid) status = nf90_inq_varid(nc%id, nc%rhill_varname, nc%rhill_varid) - param%lrhill_present = (status == NF90_NOERR) status = nf90_inq_varid(nc%id, nc%npl_varname, nc%npl_varid) status = nf90_inq_varid(nc%id, nc%status_varname, nc%status_varid) status = nf90_inq_varid(nc%id, nc%ntp_varname, nc%ntp_varid) @@ -1232,7 +1231,6 @@ module function swiftest_io_netcdf_read_frame_system(self, nc, param) result(ier status = nf90_get_var(nc%id, nc%rhill_varid, rtemp, start=[1, tslot], count=[idmax,1]) if (status == NF90_NOERR) then pl%rhill(:) = pack(rtemp, plmask) - param%lrhill_present = .true. end if end if diff --git a/src/swiftest/swiftest_kick.f90 b/src/swiftest/swiftest_kick.f90 index 430679b43..751702fa2 100644 --- a/src/swiftest/swiftest_kick.f90 +++ b/src/swiftest/swiftest_kick.f90 @@ -430,7 +430,7 @@ pure module subroutine swiftest_kick_getacch_int_one_tp(rji2, xr, yr, zr, GMpl, ! Internals real(DP) :: fac - fac = GMpl * sqrt(1.0_DP / (rji2*rji2*rji2)) + fac = GMpl / (rji2*sqrt(rji2)) ax = ax - fac * xr ay = ay - fac * yr az = az - fac * zr diff --git a/src/swiftest/swiftest_module.f90 b/src/swiftest/swiftest_module.f90 index c86f86dd1..f7be030d1 100644 --- a/src/swiftest/swiftest_module.f90 +++ b/src/swiftest/swiftest_module.f90 @@ -146,7 +146,6 @@ module swiftest procedure :: read_in => swiftest_io_read_in_body !! Read in body initial conditions from an ascii file procedure :: write_frame => swiftest_io_netcdf_write_frame_body !! I/O routine for writing out a single frame of time-series data for all bodies in the nbody_system in NetCDF format procedure :: write_info => swiftest_io_netcdf_write_info_body !! Dump contents of particle information metadata to file - procedure :: accel_obl => swiftest_obl_acc_body !! Compute the barycentric accelerations of bodies due to the oblateness of the central body procedure :: el2xv => swiftest_orbel_el2xv_vec !! Convert orbital elements to position and velocity vectors procedure :: xv2el => swiftest_orbel_xv2el_vec !! Convert position and velocity vectors to orbital elements procedure :: setup => swiftest_util_setup_body !! A constructor that sets the number of bodies and allocates all allocatable arrays @@ -995,11 +994,18 @@ pure module subroutine swiftest_kick_getacch_int_one_tp(rji2, xr, yr, zr, Gmpl, real(DP), intent(inout) :: ax, ay, az !! Acceleration vector components of test particle end subroutine swiftest_kick_getacch_int_one_tp - module subroutine swiftest_obl_acc_body(self, nbody_system) - implicit none - class(swiftest_body), intent(inout) :: self !! Swiftest body object - class(swiftest_nbody_system), intent(inout) :: nbody_system !! Swiftest nbody system object - end subroutine swiftest_obl_acc_body + module subroutine swiftest_obl_acc(n, GMcb, j2rp2, j4rp4, rh, lmask, aobl, GMpl, aoblcb) + implicit none + integer(I4B), intent(in) :: n !! Number of bodies + real(DP), intent(in) :: GMcb !! Central body G*Mass + real(DP), intent(in) :: j2rp2 !! J2 * R**2 for the central body + real(DP), intent(in) :: j4rp4 !! J4 * R**4 for the central body + real(DP), dimension(:,:), intent(in) :: rh !! Heliocentric positions of bodies + logical, dimension(:), intent(in) :: lmask !! Logical mask of bodies to compute aobl + real(DP), dimension(:,:), intent(out) :: aobl !! Barycentric acceleration of bodies due to central body oblateness + real(DP), dimension(:), intent(in), optional :: GMpl !! Masses of input bodies if they are not test particles + real(DP), dimension(:), intent(out), optional :: aoblcb !! Barycentric acceleration of central body (only needed if input bodies are massive) + end subroutine swiftest_obl_acc module subroutine swiftest_obl_acc_pl(self, nbody_system) implicit none diff --git a/src/swiftest/swiftest_obl.f90 b/src/swiftest/swiftest_obl.f90 index 2b87b7264..6bd7480fb 100644 --- a/src/swiftest/swiftest_obl.f90 +++ b/src/swiftest/swiftest_obl.f90 @@ -9,7 +9,7 @@ submodule (swiftest) s_swiftest_obl contains - module subroutine swiftest_obl_acc_body(self, nbody_system) + module subroutine swiftest_obl_acc(n, GMcb, j2rp2, j4rp4, rh, lmask, aobl, GMpl, aoblcb) !! author: David A. Minton !! !! Compute the barycentric accelerations of bodies due to the oblateness of the central body @@ -19,33 +19,46 @@ module subroutine swiftest_obl_acc_body(self, nbody_system) !! Adapted from Hal Levison's Swift routine obl_acc.f and obl_acc_tp.f implicit none ! Arguments - class(swiftest_body), intent(inout) :: self !! Swiftest body object - class(swiftest_nbody_system), intent(inout) :: nbody_system !! Swiftest nbody system object + integer(I4B), intent(in) :: n !! Number of bodies + real(DP), intent(in) :: GMcb !! Central body G*Mass + real(DP), intent(in) :: j2rp2 !! J2 * R**2 for the central body + real(DP), intent(in) :: j4rp4 !! J4 * R**4 for the central body + real(DP), dimension(:,:), intent(in) :: rh !! Heliocentric positions of bodies + logical, dimension(:), intent(in) :: lmask !! Logical mask of bodies to compute aobl + real(DP), dimension(:,:), intent(out) :: aobl !! Barycentric acceleration of bodies due to central body oblateness + real(DP), dimension(:), intent(in), optional :: GMpl !! Masses of input bodies if they are not test particles + real(DP), dimension(:), intent(out), optional :: aoblcb !! Barycentric acceleration of central body (only needed if input bodies are massive) ! Internals integer(I4B) :: i real(DP) :: r2, irh, rinv2, t0, t1, t2, t3, fac1, fac2 - if (self%nbody == 0) return - - associate(n => self%nbody, cb => nbody_system%cb) - self%aobl(:,:) = 0.0_DP - do concurrent(i = 1:n, self%lmask(i)) - r2 = dot_product(self%rh(:, i), self%rh(:, i)) - irh = 1.0_DP / sqrt(r2) - rinv2 = irh**2 - t0 = -cb%Gmass * rinv2 * rinv2 * irh - t1 = 1.5_DP * cb%j2rp2 - t2 = self%rh(3, i) * self%rh(3, i) * rinv2 - t3 = 1.875_DP * cb%j4rp4 * rinv2 - fac1 = t0 * (t1 - t3 - (5 * t1 - (14.0_DP - 21.0_DP * t2) * t3) * t2) - fac2 = 2 * t0 * (t1 - (2.0_DP - (14.0_DP * t2 / 3.0_DP)) * t3) - self%aobl(:, i) = fac1 * self%rh(:, i) - self%aobl(3, i) = fac2 * self%rh(3, i) + self%aobl(3, i) + if (n == 0) return + + aobl(:,:) = 0.0_DP + do concurrent(i = 1:n, lmask(i)) + r2 = dot_product(rh(:, i), rh(:, i)) + irh = 1.0_DP / sqrt(r2) + rinv2 = irh**2 + t0 = -GMcb * rinv2 * rinv2 * irh + t1 = 1.5_DP * j2rp2 + t2 = rh(3, i) * rh(3, i) * rinv2 + t3 = 1.875_DP * j4rp4 * rinv2 + fac1 = t0 * (t1 - t3 - (5 * t1 - (14.0_DP - 21.0_DP * t2) * t3) * t2) + fac2 = 2 * t0 * (t1 - (2.0_DP - (14.0_DP * t2 / 3.0_DP)) * t3) + aobl(:, i) = fac1 * rh(:, i) + aobl(3, i) = fac2 * rh(3, i) + aobl(3, i) + end do + + if (present(GMpl) .and. present(aoblcb)) then + aoblcb(:) = 0.0_DP + do i = n, 1, -1 + if (lmask(i)) aoblcb(:) = aoblcb(:) - GMpl(i) * aobl(:, i) / GMcb end do - end associate + end if + return - end subroutine swiftest_obl_acc_body + end subroutine swiftest_obl_acc module subroutine swiftest_obl_acc_pl(self, nbody_system) @@ -65,11 +78,7 @@ module subroutine swiftest_obl_acc_pl(self, nbody_system) if (self%nbody == 0) return associate(pl => self, npl => self%nbody, cb => nbody_system%cb) - call swiftest_obl_acc_body(pl, nbody_system) - cb%aobl(:) = 0.0_DP - do i = npl, 1, -1 - if (pl%lmask(i)) cb%aobl(:) = cb%aobl(:) - pl%Gmass(i) * pl%aobl(:, i) / cb%Gmass - end do + call swiftest_obl_acc(npl, cb%Gmass, cb%j2rp2, cb%j4rp4, pl%rh, pl%lmask, pl%aobl, pl%Gmass, cb%aobl) do concurrent(i = 1:npl, pl%lmask(i)) pl%ah(:, i) = pl%ah(:, i) + pl%aobl(:, i) - cb%aobl(:) @@ -99,7 +108,7 @@ module subroutine swiftest_obl_acc_tp(self, nbody_system) if (self%nbody == 0) return associate(tp => self, ntp => self%nbody, cb => nbody_system%cb) - call swiftest_obl_acc_body(tp, nbody_system) + call swiftest_obl_acc(ntp, cb%Gmass, cb%j2rp2, cb%j4rp4, tp%rh, tp%lmask, tp%aobl) if (nbody_system%lbeg) then aoblcb = cb%aoblbeg else diff --git a/src/swiftest/swiftest_util.f90 b/src/swiftest/swiftest_util.f90 index be98690c3..b620a7f9d 100644 --- a/src/swiftest/swiftest_util.f90 +++ b/src/swiftest/swiftest_util.f90 @@ -110,7 +110,6 @@ module subroutine swiftest_util_append_arr_kin(arr, source, nold, lsource_mask) end subroutine swiftest_util_append_arr_kin - module subroutine swiftest_util_append_body(self, source, lsource_mask) !! author: David A. Minton !! @@ -829,7 +828,6 @@ module subroutine swiftest_util_dealloc_tp(self) end subroutine swiftest_util_dealloc_tp - module subroutine swiftest_util_fill_arr_info(keeps, inserts, lfill_list) !! author: David A. Minton !! @@ -2609,7 +2607,7 @@ module subroutine swiftest_util_snapshot_system(self, param, nbody_system, t, ar end select end select - call nbody_system%pl%set_rhill(nbody_system%cb) + if (.not.param%lrhill_present) call nbody_system%pl%set_rhill(nbody_system%cb) ! Take a minimal snapshot wihout all of the extra storage objects allocate(snapshot, mold=nbody_system) @@ -2825,6 +2823,7 @@ module subroutine swiftest_util_sort_tp(self, sortby, ascending) return end subroutine swiftest_util_sort_tp + module subroutine swiftest_util_sort_rearrange_body(self, ind) !! author: David A. Minton !! @@ -3200,7 +3199,6 @@ module subroutine swiftest_util_spill_tp(self, discards, lspill_list, ldestructi end subroutine swiftest_util_spill_tp - module subroutine swiftest_util_valid_id_system(self, param) !! author: David A. Minton !! diff --git a/src/whm/whm_kick.f90 b/src/whm/whm_kick.f90 index 6469809e5..403678ed6 100644 --- a/src/whm/whm_kick.f90 +++ b/src/whm/whm_kick.f90 @@ -124,14 +124,13 @@ function whm_kick_getacch_ah0(mu, rhp, n) result(ah0) ! Result real(DP), dimension(NDIM) :: ah0 ! Internals - real(DP) :: fac, r2, ir3h, irh + real(DP) :: fac, r2, ir3h integer(I4B) :: i ah0(:) = 0.0_DP do i = 1, n r2 = dot_product(rhp(:, i), rhp(:, i)) - irh = 1.0_DP / sqrt(r2) - ir3h = irh / r2 + ir3h = 1.0_DP / (r2 * sqrt(r2)) fac = mu(i) * ir3h ah0(:) = ah0(:) - fac * rhp(:, i) end do