{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "46aa05cc",
   "metadata": {},
   "source": [
    "# Writing a new data exporter\n",
    "\n",
    "Writing a new DataExporter is very similar process to [writing a new DataLoader](https://bwheelz36.github.io/ParticlePhaseSpace/new_data_loader.html#).\n",
    "As an example: lets say that I want to export some topas to the same format used in the [data import example](https://bwheelz36.github.io/ParticlePhaseSpace/new_data_loader.html#):\n",
    "\n",
    "```\n",
    "x (mm)\ty (mm)\tz (mm)\tpx (MeV/c)\tpy (MeV/c)\tpz (MeV/c)\tE (MeV)\n",
    "```\n",
    "\n",
    "> Note that these units already match those in the unit set of `mm_MeV`\n",
    "\n",
    "To do this, we would create a data exporter as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8b8cfdb7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-13T05:33:34.705045Z",
     "iopub.status.busy": "2023-04-13T05:33:34.704676Z",
     "iopub.status.idle": "2023-04-13T05:33:35.780212Z",
     "shell.execute_reply": "2023-04-13T05:33:35.779315Z"
    }
   },
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import sys\n",
    "sys.path.append('../')\n",
    "from ParticlePhaseSpace.DataExporters import _DataExportersBase\n",
    "from ParticlePhaseSpace import DataLoaders\n",
    "from ParticlePhaseSpace._ParticlePhaseSpace import PhaseSpace\n",
    "import numpy as np\n",
    "import ParticlePhaseSpace.__particle_config__ as particle_cfg\n",
    "from ParticlePhaseSpace import ParticlePhaseSpaceUnits\n",
    "\n",
    "class NewDataExporter(_DataExportersBase):\n",
    "    \n",
    "    def _define_required_columns(self):\n",
    "        pass\n",
    "        \n",
    "    def _export_data(self):\n",
    "        pass\n",
    "    \n",
    "    def _set_expected_units(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d28c1c36",
   "metadata": {},
   "source": [
    "Our job is to fill in these blank methods.\n",
    "\n",
    "- in `_define_required_columns` you must list all the columns required for your data export. These column names must match  the [allowed columns](https://bwheelz36.github.io/ParticlePhaseSpace/phase_space_format.html#allowed-columns) from the phase space specification.\n",
    "- in `set_expected_units` you should list the units your exporter is expecting. If the units in the data it receives are different, it will attempt to convert the data to the correct units.\n",
    "- `_export_data` is where the data export will actually happen.\n",
    "\n",
    "The filled in data exporter for the case in hand looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c814a61a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-13T05:33:35.784509Z",
     "iopub.status.busy": "2023-04-13T05:33:35.784166Z",
     "iopub.status.idle": "2023-04-13T05:33:35.792171Z",
     "shell.execute_reply": "2023-04-13T05:33:35.791215Z"
    }
   },
   "outputs": [],
   "source": [
    "class NewDataExporter(_DataExportersBase):\n",
    "\n",
    "    def _define_required_columns(self):\n",
    "        self._required_columns = ['x', 'y', 'z', 'px', 'py', 'pz', 'Ek']\n",
    "    \n",
    "    def _set_expected_units(self):\n",
    "        self._expected_units = ParticlePhaseSpaceUnits()('mm_MeV')\n",
    "    \n",
    "    \n",
    "    def _export_data(self):\n",
    "\n",
    "        if not Path(self._output_name).suffix == '.dat':\n",
    "            _output_name = str(self._output_name) + '.dat'\n",
    "        else:\n",
    "            _output_name = self._output_name\n",
    "        WritefilePath = Path(self._output_location) / _output_name\n",
    "\n",
    "        header = 'x (mm)\\ty (mm)\\tz (mm)\\tpx (MeV/c)\\tpy (MeV/c)\\tpz (MeV/c)\\tE (MeV)'\n",
    "        Data = [self._PS.ps_data['x [mm]'].to_numpy(), self._PS.ps_data['y [mm]'].to_numpy(), self._PS.ps_data['z [mm]'].to_numpy(),\n",
    "                self._PS.ps_data['px [MeV/c]'].to_numpy(), self._PS.ps_data['py [MeV/c]'].to_numpy(),\n",
    "                self._PS.ps_data['pz [MeV/c]'].to_numpy(),\n",
    "                self._PS.ps_data['Ek [MeV]'].to_numpy()]\n",
    "        Data = np.transpose(Data)\n",
    "        FormatSpec = ['%11.5f', '%11.5f', '%11.5f', '%11.5f', '%11.5f', '%11.5f', '%11.5f']\n",
    "        np.savetxt(WritefilePath, Data, fmt=FormatSpec, delimiter='      ', header=header, comments='')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b95dc5",
   "metadata": {},
   "source": [
    "## Testing the data export\n",
    "\n",
    "Let's test the use case of loading in some topas data, and exporting it with this data exporter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "48e6a00f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-13T05:33:35.795825Z",
     "iopub.status.busy": "2023-04-13T05:33:35.795562Z",
     "iopub.status.idle": "2023-04-13T05:33:36.014010Z",
     "shell.execute_reply": "2023-04-13T05:33:36.013156Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.NewDataExporter at 0x7f819239b4c0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load topas data:\n",
    "data_loc = Path('../tests/test_data/coll_PhaseSpace_xAng_0.00_yAng_0.00_angular_error_0.0.phsp')\n",
    "data = DataLoaders.Load_TopasData(data_loc)\n",
    "PS = PhaseSpace(data)\n",
    "\n",
    "# Because we only want to work with the electrons, generate an electron only phase space:\n",
    "PS_electrons = PS('electrons')\n",
    "\n",
    "NewDataExporter(PS_electrons,'.','test_new_exporter.dat')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ec9c348",
   "metadata": {},
   "source": [
    "To verify that this worked, we can recycle the [data loader]() we wrote to read this data and check if it works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c6fae3c8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-13T05:33:36.017699Z",
     "iopub.status.busy": "2023-04-13T05:33:36.017412Z",
     "iopub.status.idle": "2023-04-13T05:33:36.026985Z",
     "shell.execute_reply": "2023-04-13T05:33:36.026148Z"
    }
   },
   "outputs": [],
   "source": [
    "from ParticlePhaseSpace.DataLoaders import _DataLoadersBase\n",
    "\n",
    "class NewDataLoader(_DataLoadersBase):\n",
    "\n",
    "    def _import_data(self):\n",
    "        Data = np.loadtxt(self._input_data, skiprows=1)\n",
    "        self.data['x [mm]'] = Data[:, 0]\n",
    "        self.data['y [mm]'] = Data[:, 1]\n",
    "        self.data['z [mm]'] = Data[:, 2]\n",
    "        self.data['px [MeV/c]'] = Data[:, 3]\n",
    "        self.data['py [MeV/c]'] = Data[:, 4]\n",
    "        self.data['pz [MeV/c]'] = Data[:, 5]\n",
    "        self.data['particle type [pdg_code]'] = particle_cfg.particle_properties[self._particle_type]['name']\n",
    "        # we also need to fill in weight, particle id, and time; since none of these are specified we just use all\n",
    "        # ones for weight, 1,2,3... for particle id, and all zeros for time:\n",
    "        self.data['weight'] = np.ones(Data.shape[0])\n",
    "        self.data['particle id'] = np.arange(len(self.data))\n",
    "\n",
    "        self.data['time [ps]'] = 0  # may want to replace with time feature if available?\n",
    "\n",
    "        # because we have momentum and energy, we can double check that our momentum to energy conversion is \n",
    "        # consisten with the values in the phase space:\n",
    "        E = Data[:, 6]\n",
    "        self._check_energy_consistency(Ek=E)\n",
    "\n",
    "    def _check_input_data(self):\n",
    "        # is the input a file?\n",
    "        if not Path(self._input_data).is_file():\n",
    "            raise FileNotFoundError(f'input data file {self._import_data()} does not exist')\n",
    "        # does it have the right extension?\n",
    "        if not Path(self._input_data).suffix == '.dat':\n",
    "            raise Exception('This data loaders requires a *.dat file')\n",
    "        # the header is on the first line; does it look correct?\n",
    "        with open(self._input_data) as f:\n",
    "            first_line = f.readline()\n",
    "            if not first_line == 'x (mm)\\ty (mm)\\tz (mm)\\tpx (MeV/c)\\tpy (MeV/c)\\tpz (MeV/c)\\tE (MeV)\\n':\n",
    "                raise Exception('file header does not look correct')\n",
    "        if not self._particle_type:\n",
    "            raise Exception('this data loader requires particle_type to be specified')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a14268a3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-13T05:33:36.030815Z",
     "iopub.status.busy": "2023-04-13T05:33:36.030435Z",
     "iopub.status.idle": "2023-04-13T05:33:36.440110Z",
     "shell.execute_reply": "2023-04-13T05:33:36.439188Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7l0lEQVR4nO3dfVxUZf7/8feAMCIIdGMLKgIqSqVmrpotKmqGbm1l27atrSUaZrrmiq6K/lJQ10VaE7f2W1bkTdnN7n7tztoCDYEiy76ibreG96Sh7neVEUxEOb8/XOa7I4PCMDDM4fV8PObxiHNdc85nnIx313Wd61gMwzAEAAAAr+fj6QIAAADgHgQ7AAAAkyDYAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMoo2nC/B21dXVOnLkiNq3by+LxeLpcgAAgMkYhqFTp06pY8eO8vG59Jgcwa6Rjhw5ooiICE+XAQAATK6kpESdO3e+ZB+CXSO1b99e0oU/7ODgYA9XAwAAzMZmsykiIsKeOS6FYNdINdOvwcHBBDsAANBk6rPki5snAAAATIJgBwAAYBIEOwAAAJNgjR0AACZx/vx5VVVVeboMNJCfn598fX3dci6CHQAAXs4wDJWWlurkyZOeLgUuCg0NVVhYWKP3xCXYAQDg5WpC3TXXXKN27dqxYb4XMQxDp0+f1rFjxyRJ4eHhjTofwQ4AAC92/vx5e6i76qqrPF0OXBAQECBJOnbsmK655ppGTcty8wQAAF6sZk1du3btPFwJGqPm+2vsGkmCHQAAJsD0q3dz1/dHsAMAADAJgh0AAGhx8vLyZLFYuNO3gbh5AgAAk8rc9G2zXi/51h7Ner2GyMvL0/Dhw3XixAmFhoZ6upwmw4gdAADAv509e9bTJTQKwQ4AAHhEdXW10tPTFR0drYCAAN1www367//+7zr7f/TRRxoyZIgCAgIUERGh6dOnq6Kiwt5eWVmpuXPnKiIiQlarVd27d9cLL7ygAwcOaPjw4ZKkK664QhaLRYmJiZKkYcOGadq0aZoxY4auvvpqjRo1SpKUn5+vgQMHymq1Kjw8XCkpKTp37pz9WsOGDdP06dM1Z84cXXnllQoLC1NaWpq93TAMpaWlqUuXLrJarerYsaOmT5/uxj8955iKBQAAHpGenq7169dr1apViomJUUFBgcaNG6cOHTrU6rt3716NHj1av//977V69WodP35c06ZN07Rp07RmzRpJ0oMPPqitW7fqySef1A033KD9+/frn//8pyIiIrRhwwbdc8892r17t4KDg+17x0nSunXrNGXKFBUWFkqSDh8+rNtuu02JiYl68cUX9c0332jSpElq27atQ3hbt26dZs6cqU8//VRbt25VYmKi4uLidOutt2rDhg3KzMzUa6+9puuvv16lpaXatWtX0/6BSrIYhmE0+VVMzGazKSQkRGVlZQoODvZ0OQCAVubMmTPav3+/oqOj1bZtW4e2lrzGrrKyUldeeaU2b96sm2++2X48KSlJp0+f1sMPP+ywJi4pKUm+vr569tln7X0/+ugjxcfHq6KiQocOHVLPnj21adMmjRw5stb16lpjN2zYMNlsNhUVFdmP/b//9/+0YcMGff311/ZtSJ5++mnNnTtXZWVl8vHx0bBhw3T+/Hl9+OGH9vcNHDhQI0aM0LJly7RixQo9++yz+uKLL+Tn53fZP49LfY8NyRqM2KFFcfYfoZa8GBcA4Jo9e/bo9OnTuvXWWx2Onz17VjfeeGOt/rt27dI//vEPvfzyy/ZjhmGourpa+/fv1+effy5fX1/Fx8c3uJYf//jHDj9//fXXuvnmmx32louLi1N5ebm+++47denSRZLUp08fh/eFh4fbHw127733auXKleratatGjx6t2267TXfccYfatGna6EWwAwAAza68vFyS9O6776pTp04ObVarVXv37q3Vf/LkyU7XqXXp0kV79uxxuZbAwECX3nfxSJzFYlF1dbUkKSIiQrt379bmzZu1adMmTZ06VX/84x+Vn59frxE8VxHsAABAs7vuuutktVp16NAhp6NsFwe7fv366auvvlL37t2dnq93796qrq5Wfn6+06lYf39/SReerXs51157rTZs2CDDMOyjdoWFhWrfvr06d+582ffXCAgI0B133KE77rhDv/nNbxQbG6vPP/9c/fr1q/c5GopgBwAAml379u31u9/9TsnJyaqurtbgwYNVVlamwsJCBQcHKzIy0qH/3LlzNWjQIE2bNk1JSUkKDAzUV199pU2bNunPf/6zoqKiNH78eE2cONF+88TBgwd17Ngx/fKXv1RkZKQsFoveeecd3XbbbQoICFBQUJDT2qZOnaqVK1fq0Ucf1bRp07R7926lpqZq5syZ8vGp34Yia9eu1fnz53XTTTepXbt2Wr9+vQICAmp9LndjuxMAAOARS5Ys0YIFC5Senq5rr71Wo0eP1rvvvqvo6Ohaffv06aP8/Hx9++23GjJkiG688UYtXLhQHTt2tPd55pln9Itf/EJTp05VbGysJk2aZN8OpVOnTlq0aJFSUlL0ox/9SNOmTauzrk6dOunvf/+7tm3bphtuuEGPPPKIHnroIT322GP1/myhoaF6/vnnFRcXpz59+mjz5s3auHGjrrrqqgb8CTUcd8U2EnfFuhc3TwBAw1zqbkp4D3fdFcuIHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAGAC3Avp3dz1/RHsAADwYjVPMTh9+rSHK0Fj1Hx/jX0qBRsUAwDgxXx9fRUaGmp/Rmm7du0cnnGKls0wDJ0+fVrHjh1TaGiofH19G3U+gh0AAF4uLCxMkuzhDt4nNDTU/j02BsEOAAAvZ7FYFB4ermuuuUZVVVWeLgcN5Ofn1+iRuhoEOwAATMLX19dtAQHeiZsnAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJhEiwx269ev1+TJk9W/f39ZrVZZLBatXbu2zv42m00zZ85UZGSkrFaroqKiNHv2bJWXlzvtX11draeeekq9e/dWQECAOnTooLFjx2rfvn1N9IkAAACaXosMdo899piee+45HTx4UOHh4ZfsW1FRofj4eGVmZio2NlbJycnq2bOnli9frhEjRujMmTO13jN58mRNnz5dhmFo+vTpGj16tF5//XUNGDBAxcXFTfWxAAAAmlSLDHZZWVk6cOCAjh8/rkceeeSSfR9//HHt3LlTc+fOVXZ2tpYtW6bs7GzNnTtXn332mTIzMx36b9myRVlZWRo6dKiKioqUkZGhl156SW+++ab+9a9/adq0aU350QAAAJpMiwx2I0eOVGRk5GX7GYahrKwsBQUFacGCBQ5tCxYsUFBQkLKyshyOP//885KkJUuWyN/f3378pz/9qYYNG6acnBwdOnTIDZ8CAACgebXIYFdfxcXFOnLkiOLi4hQYGOjQFhgYqLi4OO3bt08lJSX243l5efa2i40aNUqSlJ+f37SFAwAANAGvD3aSFBMT47S95nhNv4qKCn3//feKjo6Wr6/vZfs7U1lZKZvN5vACAABoCbw62JWVlUmSQkJCnLYHBwc79Gtof2fS09MVEhJif0VERLhWPAAAgJt5dbDzhHnz5qmsrMz++s9pXgAAAE9q4+kCGqNm5K2uEbaaadKafg3t74zVapXVanWtYAAAgCbk1SN2l1sTd/EavMDAQIWHh2v//v06f/78ZfsDAAB4E68Pdh07dlRhYaEqKioc2ioqKlRYWKjo6GiHdXDx8fH2totlZ2dLkoYOHdq0hQMAADQBrw52FotFSUlJKi8v15IlSxzalixZovLyck2aNMnh+MMPPyzpwj53Z8+etR9/7733lJeXp4SEhHrtoQcAANDSWAzDMDxdxMWysrL00UcfSZI+//xzFRUVKS4uTt27d5ckDR48WElJSZIujMzFxcVp165dSkhIUL9+/VRUVKScnBwNGDBA+fn5CggIcDj/pEmTlJWVpeuvv1633367vv/+e/3lL39RUFCQtm7dqh49etS7VpvNppCQEJWVldnvqoXrMjd9W+tY8q31/z4AADCbhmSNFnnzxEcffaR169Y5HCssLHSYPq0JdoGBgcrPz1daWpo2bNigLVu2KDw8XLNmzVJqamqtUCdJzz77rHr37q3nnntOf/rTnxQUFKS7775bS5cuVbdu3Zr2w3k5ghcAAC1Xixyx8yatbcSuqYMdwREAAEcNyRpevcYOAAAA/4dgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJhEG08XAFxO5qZvax1LvrWHByoBAKBlY8QOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASbHcCSZ7bUsTZdQEAgGsYsQMAADAJgh0AAIBJMBXbCjH9CQCAOTFiBwAAYBIEOwAAAJMg2AEAAJgEa+zQJFjHBwBA82PEDgAAwCQIdgAAACZhimBnGIZef/11DR8+XOHh4WrXrp169uypyZMna9++fbX622w2zZw5U5GRkbJarYqKitLs2bNVXl7ugeoBAADcwxTB7ne/+53uuece7d69W2PGjNGjjz6q6OhoPf/88+rbt6+++OILe9+KigrFx8crMzNTsbGxSk5OVs+ePbV8+XKNGDFCZ86c8eAnAQAAcJ3X3zxRWlqqlStXKjIyUrt27VJISIi9LTMzUzNnztSKFSu0evVqSdLjjz+unTt3au7cuVq2bJm9b0pKijIyMpSZmal58+Y1++cAAABoLK8fsTtw4ICqq6sVFxfnEOok6Wc/+5kk6fjx45IuTNlmZWUpKChICxYscOi7YMECBQUFKSsrq3kKBwAAcDOvH7GLiYmRv7+/CgsLZbPZFBwcbG975513JEm33HKLJKm4uFhHjhzRqFGjFBgY6HCewMBAxcXFKTs7WyUlJYqIiGi+D9FCsWUJAADexeuD3VVXXaVly5Zp1qxZio2N1V133aXg4GDt2rVLubm5mjp1qqZNmybpQrCTLoRBZ2JiYpSdna3i4mKCHQAA8DpeH+wkKTk5WZ06dVJSUpJWrVplPz548GDdf//9atPmwscsKyuTpFpTtjVqRvtq+jlTWVmpyspK+882m63R9QMAALiD16+xk6TFixdr3Lhxmj9/vkpKSnTq1Cl9+OGHOnPmjIYNG6a3337bbddKT09XSEiI/cXIHgAAaCm8Ptht3rxZqampmjZtmlJSUtS5c2cFBQVp8ODB2rhxo/z8/DRr1ixJ/zdSV9eIXM3oW10jepI0b948lZWV2V8lJSVu/kQAAACu8fqp2Pfee0+SNHz48FptYWFhio2N1Y4dO1ReXm5fW1ez1u5il1uDJ0lWq1VWq7WxZQMAALid14/YnT17VtL/bWlysePHj8vHx0d+fn6KiYlRx44dVVhYqIqKCod+FRUVKiwsVHR0NNOrAADAK3l9sIuLi5MkrVixotYU66pVq/Tdd9/p5ptvltVqlcViUVJSksrLy7VkyRKHvkuWLFF5ebkmTZrUbLUDAAC4k9dPxd5777165plnVFBQoB49eujOO+9UaGioioqKlJubq4CAAK1YscLef86cOXrrrbeUkZGhHTt2qF+/fioqKlJOTo4GDBigGTNmeO7DAAAANILXj9j5+voqJydH6enp6tSpk1555RWtXLlSu3fv1rhx47R9+3YNHDjQ3j8wMFD5+fmaMWOGvv76az3xxBP65ptvNGvWLH3wwQcKCAjw4KcBAABwncUwDMPTRXgzm82mkJAQlZWVOTz1oiVz9xMlkm/t0eTXqM81nXFWR33fCwBAS9CQrOH1I3YAAAC4gGAHAABgEgQ7AAAAkyDYAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMwuufFQvPa+qnTAAAgPphxA4AAMAkCHYAAAAmQbADAAAwCdbYodVxtiYw+dYeHqgEAAD3YsQOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCu2KBBuCOWgBAS8aIHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJNjuxOScbc8BAADMyaURu5KSEuXm5ur06dP2Y9XV1crIyFBcXJxGjhypd999121FAgAA4PJcGrFbsGCBNm7cqNLSUvuxpUuXKjU11f5zfn6+Pv74Yw0YMKDxVQIAAOCyXBqxKyws1MiRI+Xn5ydJMgxDf/7znxUbG6tDhw5p27ZtCgwM1B//+Ee3FgsAAIC6uRTsjh07psjISPvPO3fu1PHjx/Xoo4+qc+fO6t+/v8aMGaPPPvvMbYUCAADg0lwKdtXV1aqurrb/nJeXJ4vFohEjRtiPderUyWGqFgAAAE3LpWDXpUsXbdu2zf7zm2++qfDwcPXs2dN+rLS0VKGhoY0uEAAAAPXjUrC75557VFhYqF/84hcaN26cPvroI91zzz0Ofb766it17drVLUUCAADg8ly6K/Z3v/udcnJy9Prrr0uS+vTpo7S0NHv7wYMHtW3bNqWkpLilSAAAAFyeS8EuODhYn3zyib744gtJ0rXXXitfX1+HPq+//rr69+/f+AoBAABQLy4Fu0OHDik0NFS9evVy2h4ZGakrr7xSJ06caFRxAAAAqD+X1thFR0dr5cqVl+zz5JNPKjo62pXTAwAAwAUuBTvDMNzSBwAAAO7jUrCrj++++07t27dvqtMDAADgIvVeY7d48WKHn/Py8pz2O3/+vEpKSvTaa69p0KBBjSoOaC6Zm76tdSz51h4eqAQAANfVO9j953YmFotFeXl5dYY7SerYsaMyMjIaUxsAAAAaoN7BbsuWLZIurJ0bMWKEEhMTNX78+Fr9fH19deWVVyo2NlY+Pk020wsAAICL1DvYxcfH2/85NTVVw4cP19ChQ5ukKAAAADScS/vYpaamursOAAAANJJLwa5GaWmptm/frpMnT+r8+fNO+zz44IONuQQAAADqyaVgd+bMGU2aNEmvvfaaqqurnfYxDEMWi4VgBwAA0ExcCnYpKSl6+eWX1aNHD40dO1adO3dWmzaNGvwDWhxnW6AAANCSuZTG/vrXv+q6667T9u3bZbVa3V0TAAAAXODSfiQnT57U6NGjCXUAAAAtiEsjdj179tTRo0fdXQvQKJ6aOr34ujyxAgDgKS6N2M2ePVtvvfWW9uzZ4+56AAAA4CKXRuw6d+6sUaNGaeDAgZoxY4b69eun4OBgp33ZxBgAAKB5uBTshg0bJovFIsMwlJaWJovFUmffuva3AwAAgHu5FOwWLlx4yTDnKW+88YaefvppFRUVqaKiQuHh4Ro0aJAef/xxRURE2PvZbDalpaVpw4YNKi0tVXh4uO69916lpqYqKCjIg58AAADAdS4Fu7S0NDeX0TiGYeiRRx7Rc889p27duulXv/qV2rdvryNHjig/P18HDx60B7uKigrFx8dr586dSkhI0NixY7Vjxw4tX75c+fn5KigoUNu2bT38iQAAABrOFLsKP/nkk3ruuec0depUPfnkk/L19XVoP3funP2fH3/8ce3cuVNz587VsmXL7MdTUlKUkZGhzMxMzZs3r9lqBwAAcBeLYRiGp4tojB9++EGdOnXSFVdcod27d1/yCRiGYahz586y2WwqLS1VYGCgva2iokJhYWG65pprtHfv3npf32azKSQkRGVlZXXeQOJJZn16grMtRVrKZ2W7EwCAOzUka7g0Yufj41OvNXYWi8VhtKwp5OTk6MSJE5owYYLOnz+vt99+W99++61CQ0M1cuRIde/e3d63uLhYR44c0ahRoxxCnSQFBgYqLi5O2dnZKikpcViTBwAA4A1cCnZDhw51GuzKyspUXFysiooK3XDDDQoNDW1sfZe1fft2SZKvr6/69Omjb7/9v1EbHx8fJScna/ny5ZIuBDtJiomJcXqumJgYZWdnq7i4mGAHAAC8jkvBLi8vr86206dPKyUlRe+//742bdrkal31duzYMUnSihUr1K9fP23btk3XXnutduzYoYcfflhPPPGEunXrpilTpqisrEySFBIS4vRcNcObNf2cqaysVGVlpf1nm83mro8CAADQKC49eeJS2rVrpyeffFIhISGaPXu2u09fS3V1tSTJ399fb775pgYMGKCgoCANGTJEf/vb3+Tj46MnnnjCbddLT09XSEiI/cXIHgAAaCncHuxqDBkyRO+++25Tnd6uZvStf//+6tixo0Nbr1691LVrV+3du1cnT560961rRK5m9K2uET1JmjdvnsrKyuyvkpISd3wMAACARmuy7U6OHz+u8vLypjq9Xc+ePSWpzvV8Ncd/+OEH+9q6mrV2F7vcGjxJslqtslqtLlYLAADQdNwe7Kqrq/Xyyy/rL3/5i/r37+/u09cyfPhwSdLXX39dq62qqkp79uxRYGCgOnTooLCwMHXs2FGFhYWqqKiotd1JYWGhoqOjmV71Ai1laxMAAFoSl6Ziu3bt6vTVpUsXtWvXTomJifLx8VF6erq7662lW7duSkhI0J49e5SVleXQtmzZMp08eVJ333232rRpI4vFoqSkJJWXl2vJkiUOfZcsWaLy8nJNmjSpyWsGAABoCi5tUBwVFeV0uxMfHx9dccUVGjBggKZNm6brr7/eLUVezt69e/WTn/xEx44d0+23367Y2Fjt2LFDubm5ioyM1CeffKKwsDBJF0bm4uLitGvXLiUkJKhfv34qKipSTk6OBgwYoPz8fAUEBNT72mxQjIuxQTEAwJ0akjW8/skTNUpKSrRw4UK9//77+t///V+FhYXpzjvv1MKFC3XNNdc49C0rK1NaWpo2bNig0tJShYeH695771Vqaqrat2/foOsS7HAxgh0AwJ1aZbDzFIId6qO+Yc/Z90VQBIDWrckfKfafDh8+rJ07d8pmsyk4OFh9+/ZVp06dGntaAAAANJDLwW7Pnj2aMmWKcnNza7Xdcsstevrppx2e0woAAICm5VKwKykp0eDBg3Xs2DHFxsZq6NChCg8PV2lpqQoKCrR582YNGTJE27ZtY+sQAACAZuJSsFu0aJGOHTump59+WpMnT651h+yzzz6rKVOmaPHixXr++efdUigAAAAuzaVgl52drTvuuEOPPPKI0/bJkyfr73//u957771GFQcAAID6c2mD4mPHjqlXr16X7NOrVy8dP37cpaIAAADQcC4Fuw4dOuirr766ZJ+vvvpKHTp0cKkoAAAANJxLwW7UqFF6++239cILLzhtX716tTZu3KjRo0c3qjgAAADUn0tr7FJTU7Vx40Y9/PDDWrlypeLj4/WjH/1IR48eVUFBgb788ktdffXVSk1NdXe9AAAAqINLwa5Lly4qLCzU5MmTlZeXpy+//NKhffjw4XrmmWfY6gT4N54oAQBoDi5vUBwTE6Pc3FyVlJTUevIEgQ4AAKD5NfqRYhEREQQ5AACAFsClYPfdd9+pqKhIQ4cOVWhoaK32EydO6MMPP9SPf/xjnhsL1MHZ9CwAAI3h0l2xv//97zVhwgQFBAQ4bW/Xrp0mTpyo9PT0RhUHAACA+nMp2OXm5iohIUFWq9Vpu9VqVUJCgjZv3tyo4gAAAFB/LgW7w4cPKyoq6pJ9IiMjdfjwYVdODwAAABe4FOz8/f1ls9ku2cdms8lisbhUFAAAABrOpWDXu3dvbdy4UZWVlU7bz5w5o7ffflu9e/duVHEAAACoP5eC3YQJE/Tdd9/pzjvv1L59+xza9u7dq7vuuktHjhxRUlKSW4oEAADA5bm03cmECRP097//XRs2bFBsbKyio6PVqVMnHT58WPv379e5c+d03333acKECe6uFwAAAHVwacROkv7617/qySefVPfu3VVcXKy8vDwVFxerR48e+q//+i+9+uqr7qwTAAAAl+HykycsFoumTZumadOmqaKiQmVlZQoJCVFgYKA76wMAAEA9NfqRYpIUGBhIoAMAAPAwl6diAQAA0LIQ7AAAAEyCYAcAAGASblljh5Yhc9O3ni4BAAB4ECN2AAAAJkGwAwAAMAmCHQAAgEnUe43dxIkTG3xyi8WiF154ocHvAwAAQMPVO9itXbu23ie1WCwyDINgBwAA0IzqHey2bt1ar3579uxRWlqa9u7d63JRAAAAaLh6B7ubbrrpku3//Oc/tWjRIj3//PM6e/asBg8erIyMjEYXCAAAgPpp9D52p0+f1vLly/XEE0/o1KlTuv766/WHP/xBd9xxhzvqAwAAQD25HOzOnz+vZ599VkuWLNHRo0fVuXNnrVy5UuPHj5ePDzfbAgAANDeXgt3f/vY3PfbYY9qzZ49CQkK0bNkyTZ8+XW3btnV3fQAAAKinBgW7vLw8zZ07V//zP/8jf39/zZo1S/Pnz1doaGgTlQcAAID6qnew++lPf6qcnBz5+Pho/PjxWrx4sTp37tyUtQEAAKAB6h3ssrOzZbFY1KVLF5WWlurhhx++7HssFovefffdRhUIAACA+mnQVKxhGNq/f7/2799fr/4Wi8WlogAAANBw9Q529Q1zAAAA8Ix6B7vIyMimrAMAAACN1OgNigE0v8xN39Y6lnxrDw9UAgBoSdhJGAAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMgmAHAABgEgQ7AAAAkyDYAQAAmATBDgAAwCR48gRgEjyNAgBg2hG7jIwMWSwWWSwWffLJJ7XabTabZs6cqcjISFmtVkVFRWn27NkqLy/3QLUAAACNZ8pg98UXXyg1NVWBgYFO2ysqKhQfH6/MzEzFxsYqOTlZPXv21PLlyzVixAidOXOmmSsGAABoPNMFu6qqKo0fP159+/bV3Xff7bTP448/rp07d2ru3LnKzs7WsmXLlJ2drblz5+qzzz5TZmZmM1cNAADQeKYLdkuXLtWXX36p1atXy9fXt1a7YRjKyspSUFCQFixY4NC2YMECBQUFKSsrq7nKBVqFzE3f1noBANzPVMGuqKhIS5cuVWpqqq677jqnfYqLi3XkyBHFxcXVmqoNDAxUXFyc9u3bp5KSkuYoGQAAwG1ME+wqKyv14IMPqm/fvpozZ06d/YqLiyVJMTExTttrjtf0c3Ydm83m8AIAAGgJTLPdycKFC1VcXKzt27c7nYKtUVZWJkkKCQlx2h4cHOzQ72Lp6elatGhRI6sF6s/d05ZsiwIA5mWKEbutW7dq+fLleuyxx9SrV68mvda8efNUVlZmfzFlCwAAWgqvH7E7d+6cxo8frz59+iglJeWy/WtG6uoakauZWq1rRM9qtcpqtbpYLQAAQNPx+mBXXl5uXw/n7+/vtM/NN98sSXrjjTfsN1XUtYbucmvwAAAAWiqvD3ZWq1UPPfSQ07aCggIVFxfrzjvvVIcOHRQVFaWYmBh17NhRhYWFqqiocLgztqKiQoWFhYqOjlZERERzfQTAK9R3rR/r9QDAc7w+2AUEBNS571xiYqKKi4s1b948DRo0yH48KSlJixcv1pIlS7Rs2TL78SVLlqi8vFzz589v8roBAADczeuDnSvmzJmjt956SxkZGdqxY4f69eunoqIi5eTkaMCAAZoxY4anSwQAAGiwVhnsAgMDlZ+fr7S0NG3YsEFbtmxReHi4Zs2apdTUVAUEBHi6RMAtvO0JD2zFAgCNY+pgt3btWq1du9ZpW0hIiDIzM3kuLAAAMA1T7GMHAAAAgh0AAIBpmHoqFkD9XLy2jXVtAOCdGLEDAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCZ48AcAjLn7aBQCg8RixAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmePOHF2LkfTcXb/t1yVm/yrT08UAkAeBYjdgAAACZBsAMAADAJgh0AAIBJsMYOgFt52/o8ADATRuwAAABMgmAHAABgEkzFAvA67pzuZasUAGbCiB0AAIBJEOwAAABMgmAHAABgEqyxAwAPuHhtH+v6ALgDI3YAAAAmQbADAAAwCaZiAbRoPMkCAOqPETsAAACTINgBAACYBFOxAHARnkYBwFsxYgcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACT4JFiAOAiHj0GoKVhxA4AAMAkCHYAAAAmQbADAAAwCa8PdocPH9bKlSuVkJCgLl26yN/fX2FhYbrnnnv06aefOn2PzWbTzJkzFRkZKavVqqioKM2ePVvl5eXNXD0AAID7eH2we+qpp5ScnKx9+/YpISFBs2bN0uDBg/XWW2/pJz/5if7yl7849K+oqFB8fLwyMzMVGxur5ORk9ezZU8uXL9eIESN05swZD30SAACAxvH6u2IHDhyovLw8xcfHOxz/8MMPdcstt2jKlCkaM2aMrFarJOnxxx/Xzp07NXfuXC1btszePyUlRRkZGcrMzNS8efOa9TMAAAC4g9eP2P385z+vFeokaciQIRo+fLhOnDihzz//XJJkGIaysrIUFBSkBQsWOPRfsGCBgoKClJWV1Sx1AwAAuJvXB7tL8fPzkyS1aXNhYLK4uFhHjhxRXFycAgMDHfoGBgYqLi5O+/btU0lJSbPXCgAA0FimDXaHDh3S5s2bFR4ert69e0u6EOwkKSYmxul7ao7X9HOmsrJSNpvN4QUAANASmDLYVVVV6YEHHlBlZaUyMjLk6+srSSorK5MkhYSEOH1fcHCwQz9n0tPTFRISYn9FRES4uXoAAADXmC7YVVdXKzExUQUFBZo0aZIeeOABt55/3rx5Kisrs7+YtgUAAC2F198V+5+qq6s1ceJEvfLKKxo3bpxWrVrl0F4zUlfXiFzNtGpdI3qSZLVa7XfYAgAAtCSmCXbV1dWaMGGCXnzxRY0dO1Zr166Vj4/jgOTl1tBdbg0eAO+RuenbFnO++rzXWZ/kW3u4fE0ArZMppmL/M9Tdd999eumll+zr6v5TTEyMOnbsqMLCQlVUVDi0VVRUqLCwUNHR0aybAwAAXsnrg13N9OuLL76oe++9V+vXr3ca6iTJYrEoKSlJ5eXlWrJkiUPbkiVLVF5erkmTJjVH2QAAAG7n9VOxixcv1rp16xQUFKQePXro97//fa0+Y8aMUd++fSVJc+bM0VtvvaWMjAzt2LFD/fr1U1FRkXJycjRgwADNmDGjeT8AAACAm3h9sDtw4IAkqby8XEuXLnXaJyoqyh7sAgMDlZ+fr7S0NG3YsEFbtmxReHi4Zs2apdTUVAUEBDRT5QAAAO5lMQzD8HQR3sxmsykkJERlZWX2ffCai7sXhwNoPGc3PLj6d5WbJwBIDcsaXr/GDgAAABd4/VQsAKA2tk8BWidG7AAAAEyCYAcAAGASBDsAAACTYI0dALQSrLsDzI8ROwAAAJMg2AEAAJgEU7EA4Ebu3Di8pU+dXlxfS6oNaK0YsQMAADAJgh0AAIBJEOwAAABMgjV2AODlGrOur6Wv4wPQMIzYAQAAmATBDgAAwCSYigUAuEV9p3WZ/gWaDiN2AAAAJkGwAwAAMAmCHQAAgEmwxg4A0CKxFg9oOEbsAAAATIJgBwAAYBJMxQIAmkxjnooBoOEYsQMAADAJgh0AAIBJMBULAF7EU1ObTKkC3oEROwAAAJMg2AEAAJgEwQ4AAMAkWGMHADAdnlqB1ooROwAAAJMg2AEAAJgEU7EAADQQU71oqRixAwAAMAmCHQAAgEkQ7AAAAEyCNXZegsf5ADCz1v7fONbswV0YsQMAADAJgh0AAIBJMBULAHDgbdOiLaVeplPREjBiBwAAYBIEOwAAAJMg2AEAAJgEa+wAAK3WxeviWBPnXVjXWBsjdgAAACZBsAMAADAJpmIBAF6jqbc2aSlbp7QkTHd6F0bsAAAATIJgBwAAYBJMxQIAWgVvm2atb70XT4syddq6MWIHAABgEgQ7AAAAkyDYAQAAmESrXWP32WefKTU1VR9//LGqqqrUu3dvzZw5U7/85S89XRoAwCRaynq3llJHfXlbvS1Jqwx2W7Zs0ahRo9S2bVv96le/Uvv27bVhwwbdd999Kikp0axZszxdIgAAQIO1uqnYc+fOadKkSfLx8VFBQYGee+45PfHEE9q1a5d69Oih+fPn6+DBg54uEwAAoMFa3Yhdbm6u9u7dqwkTJqhv37724yEhIZo/f74SExO1bt06LVy40HNFAgBMy93brrh6vsbU4YmpUnfX64yzz9CY93pCqxuxy8vLkyQlJCTUahs1apQkKT8/vzlLAgAAcItWF+yKi4slSTExMbXawsLCFBQUZO8DAADgTVrdVGxZWZmkC1OvzgQHB9v7OFNZWanKyspa57PZbG6ssrYzFeVNen4AABrDnb8HG/M7z1kd9T2fu9/rLjXnNgzjsn1bXbBrrPT0dC1atKjW8YiICA9UAwBAyzDf0wX8W2Pq8NR76+vUqVN1DkzVaHXBruYPpK5ROZvNpiuuuKLO98+bN08zZ860/1xdXa1//etfuuqqq2SxWFyqyWazKSIiQiUlJQoODnbpHHAfvo+Whe+jZeH7aHn4TlqWpvg+DMPQqVOn1LFjx8v2bXXBrmZtXXFxsX784x87tJWWlqq8vFwDBw6s8/1Wq1VWq9XhWGhoqFtqCw4O5i9lC8L30bLwfbQsfB8tD99Jy+Lu7+NyI3U1Wt3NE/Hx8ZKknJycWm3Z2dkOfQAAALxJqwt2t9xyi7p27apXXnlFO3futB8vKyvTH/7wB/n7++vBBx/0XIEAAAAuanVTsW3atFFWVpZGjRqloUOHOjxS7ODBg1q+fLmioqKatSar1arU1NRaU7zwDL6PloXvo2Xh+2h5+E5aFk9/HxajPvfOmtC2bduUmpqqjz/+WFVVVerdu7dmzpyp++67z9OlAQAAuKTVBjsAAACzaXVr7AAAAMyKYAcAAGASBDsP+uyzz3TbbbcpNDRUgYGBGjRokP761796uqxW5/Dhw1q5cqUSEhLUpUsX+fv7KywsTPfcc48+/fRTT5eHf8vIyJDFYpHFYtEnn3zi6XJarTfeeEO33nqrrrrqKrVt21bR0dEaO3asSkpKPF1aq2IYhl5//XUNHz5c4eHhateunXr27KnJkydr3759ni7PtNavX6/Jkyerf//+slqtslgsWrt2bZ39bTabZs6cqcjISFmtVkVFRWn27NkqL2+6x4Syxs5DtmzZolGjRqlt27ZO78ydNWuWp0tsNVJSUpSRkaFu3bpp2LBh6tChg4qLi/Xmm2/KMAy98sor3FTjYV988YX69++vNm3aqKKiQlu3btWgQYM8XVarYhiGHnnkET333HPq1q2bRo0apfbt2+vIkSPKz8/Xyy+/rMGDB3u6zFZj1qxZWrFihcLDw3XXXXcpODhYu3btUk5OjoKCgvTxxx+rV69eni7TdKKionTw4EFdffXVCgwM1MGDB7VmzRolJibW6ltRUaHBgwdr586dSkhI0I033qgdO3YoJydHAwYMUEFBgdq2bev+Ig00u6qqKqNbt26G1Wo1duzYYT9+8uRJo0ePHoa/v79x4MABzxXYymzYsMHIy8urdbygoMDw8/MzrrjiCuPMmTMeqAyGYRhnz541+vXrZ9x0003GuHHjDEnG1q1bPV1Wq7Ny5UpDkjF16lTj3Llztdqrqqo8UFXr9P333xs+Pj5GZGSkcfLkSYe2FStWGJKMCRMmeKg6c9u0aZP993N6erohyVizZo3TvgsXLjQkGXPnznU4PnfuXEOS8Yc//KFJamQq1gNyc3O1d+9e3X///erbt6/9eEhIiObPn6+zZ89q3bp1niuwlfn5z3/u9GkjQ4YM0fDhw3XixAl9/vnnHqgMkrR06VJ9+eWXWr16tXx9fT1dTqv0ww8/aNGiReratav+9Kc/Of0e2rRpdduiesyBAwdUXV2tuLi4Wo+Z+tnPfiZJOn78uCdKM72RI0cqMjLysv0Mw1BWVpaCgoK0YMECh7YFCxYoKChIWVlZTVIjwc4D8vLyJEkJCQm12kaNGiVJys/Pb86SUAc/Pz9J/NLylKKiIi1dulSpqam67rrrPF1Oq5WTk6MTJ05ozJgxOn/+vF5//XUtW7ZMq1at0p49ezxdXqsTExMjf39/FRYWymazObS98847ki48ZQmeU1xcrCNHjiguLk6BgYEObYGBgYqLi9O+ffuaZG0qv608oLi4WNKFv5wXCwsLU1BQkL0PPOfQoUPavHmzwsPD1bt3b0+X0+pUVlbqwQcfVN++fTVnzhxPl9Oqbd++XZLk6+urPn366Ntvv7W3+fj4KDk5WcuXL/dUea3OVVddpWXLlmnWrFmKjY11WGOXm5urqVOnatq0aZ4us1W71O/5muPZ2dkqLi5WRESEW69NsPOAsrIySao1hF4jODjY3geeUVVVpQceeECVlZXKyMhgCtADFi5cqOLiYm3fvp0/fw87duyYJGnFihXq16+ftm3bpmuvvVY7duzQww8/rCeeeELdunXTlClTPFxp65GcnKxOnTopKSlJq1atsh8fPHiw7r//fmYZPKw+v+f/s587MRULXKS6ulqJiYkqKCjQpEmT9MADD3i6pFZn69atWr58uR577DHu7GsBqqurJUn+/v568803NWDAAAUFBWnIkCH629/+Jh8fHz3xxBMerrJ1Wbx4scaNG6f58+erpKREp06d0ocffqgzZ85o2LBhevvttz1dIjyEYOcBNQm+rqRus9nqTPloWtXV1Zo4caJeeeUVjRs3zuH/hNE8zp07p/Hjx6tPnz5KSUnxdDnQ//03q3///urYsaNDW69evdS1a1ft3btXJ0+e9EB1rc/mzZuVmpqqadOmKSUlRZ07d1ZQUJAGDx6sjRs3ys/Pjy2zPKw+v+f/s587Eew8oGbO3dk6utLSUpWXl9c5L4+mU11drQkTJmjdunUaO3as1q5dKx8f/oo0t/LychUXF2vnzp3y9/e3b0pssVjsd4vffPPNslgsevPNNz1bbCvRs2dPSVJoaKjT9prjP/zwQzNV1Lq99957kqThw4fXagsLC1NsbKz27NnTpJvg4tIu9Xv+P483xe96JuE9ID4+Xunp6crJydGvfvUrh7bs7Gx7HzSfmlD34osv6r777tNLL73Eui4PsVqteuihh5y2FRQUqLi4WHfeeac6dOigqKio5i2ulaoJEF9//XWttqqqKu3Zs0eBgYHq0KFDc5fWKp09e1ZS3VuaHD9+XD4+Pva7+tH8YmJi1LFjRxUWFqqiosLhztiKigoVFhYqOjra7TdOSGKDYk+oqqoyunbteskNivfv3++x+lqb8+fPG+PHjzckGffeey8brbZgNd8TGxQ3v4SEBEOS8fzzzzscX7x4sSHJGDdunIcqa31effVVQ5Jx/fXX19qg+JlnnjEkGXFxcR6qrvVoqRsU80gxD+GRYi1HWlqaFi1apKCgIP32t791ejfZmDFjHDaThmckJiZq3bp1PFLMA/bu3auf/OQnOnbsmG6//XbFxsZqx44dys3NVWRkpD755BOFhYV5usxW4fz58xoxYoQKCgp0zTXX6M4771RoaKiKioqUm5urgIAA5eXlaeDAgZ4u1XSysrL00UcfSZI+//xzFRUVKS4uTt27d5d04a7kpKQkSRdG5uLi4rRr1y4lJCSoX79+Kioqsj9SLD8/XwEBAe4vskniIurl008/NUaPHm0EBwcbAQEBxsCBA43XXnvN02W1OjWjQJd61fV/ZGhejNh51qFDh4zExEQjLCzM8PPzMyIiIozf/OY3xtGjRz1dWqtz5swZIz093bjxxhuNdu3aGW3atDE6depkjBs3zvjqq688XZ5pXe73xfjx4x36nzx50pgxY4YRERFh+Pn5GV26dDFmzZpl2Gy2JquRETsAAACT4JY/AAAAkyDYAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMgmAHAABgEgQ7AAAAkyDYAWjVLBaLhg0b1qhzJCYmymKx2F+rVq1yT3HNbNCgQQ6fIy8vz9MlAWgggh0A0zhw4IBDMHH2ioqKarLr//a3v1Vqaqr69+/vcDwqKsp+/S+++MLpe8+fP69OnTrZ+x04cMClGu6//35ZLBa9+uqrl+xns9nUrl07hYaG6ocffpAkJSUlKTU1VfHx8S5dG4DntfF0AQDgbt26ddO4ceOctoWGhjbZdWfMmFFncPTxufD/0atXr9aKFStqtb/33ns6cuSI2rRpo3Pnzrlcw0MPPaRXX31Vq1ev1tixY+vs9+qrr+qHH37Q+PHjFRAQIOlCsJOktLQ05efnu1wDAM8h2AEwne7duystLc3TZTjw8/PT0KFDtX79emVkZMjPz8+hffXq1QoJCdENN9yggoICl68zYsQIRUdHKzc3V4cOHVKXLl2c9lu9erWkC0EQgHkwFQsAFzEMQ8nJybJYLPr1r3+tqqoqt5x34sSJOn78uDZu3Ohw/Pjx43rnnXc0duxY++iZMwUFBbrjjjt09dVXy2q1KiYmRo899phOnz5t72OxWDRhwgRVV1drzZo1Ts/z5Zdfatu2berTp0+taWMA3o1gBwD/oaqqSuPGjdPKlSs1Y8YMrV+/vtbomqvuvvtuXXHFFbUC10svvaSqqipNnDixzvc+88wzGjZsmAoLC3X77bdr+vTp6ty5s5YuXapbb71VZ8+etfdNTEyUj4+P1q5dK8Mwap2r5vqM1gHmw1QsANPZs2dPnVOxgwYN0ujRo522lZeX65577lFOTo7S09OVkpLi1rqsVqt+/etfa9WqVSotLVVYWJikC9OivXv31oABA5y+76uvvtL06dPVp08fffDBB7rqqqvsbcuWLdO8efP01FNPadasWZKkiIgIJSQk6P3331dubq5uueUWe/9z585p/fr1slqtda5DBOC9GLEDYDp79+7VokWLnL7ef/99p+/55z//qREjRuiDDz7Q6tWr3R7qakycOFHnzp3TunXrJEmffvqpvvzyy0uO1j377LM6d+6cnnrqKYdQJ0lz5sxRhw4dat0FWzMaV7OWrsY777yjo0eP6q677tKVV17pjo8EoAVhxA6A6YwaNarOAOfM0aNHFRcXp5KSEr3xxhu64447mqy2G2+8UX379tWaNWs0d+5crV69Wv7+/pccPfvkk08kSdnZ2frggw9qtfv5+embb75xOHbXXXepQ4cOeuONN1RWVqaQkBBJ3DQBmB3BDkCr9/3338tms6l79+666aabmvx6EydO1PTp07V582a99tpr9hsi6vKvf/1LkrR06dJ6X8PPz08PPPCAVqxYoVdeeUVTpkxRaWmp3nvvPXXp0kUjR45s9OcA0PIwFQug1evbt69eeOEF7d27V8OHD9fRo0eb9Hq//vWvZbValZiYKJvNdtnRs+DgYEkXNhU2DKPO18VqzvvCCy9IunCTxrlz5zRhwgT7vnoAzIW/2QAgacKECVqzZo2++eabJg93V155pcaMGaPDhw+rU6dOGjVq1CX714wi1kzJ1td1112nQYMGafv27frHP/6hNWvW2LdDAWBOBDsA+LcHH3xQa9eu1e7duzVs2DCVlpY22bWWLVumN954Q2+++eZlR8+mTp2qNm3a6NFHH9WhQ4dqtZ88eVI7duxw+t6aUbupU6fq66+/1siRIxUZGdn4DwCgRWKNHQDTudR2J5KUkpKitm3bOm174IEH5OPjo/Hjx2vYsGHasmWLwsPD3V5jVFRUvZ9b26tXLz399NOaMmWKevbsqdtuu03dunXTqVOntG/fPuXn5ysxMVGrVq2q9d777rtPM2bMUGFhoSRumgDMjmAHwHRqtjupy4wZM+oMdtKFNXA+Pj564IEHNHz4cOXm5qpjx45NUWq9TZo0SX379tWKFStUUFCgjRs3KiQkRF26dFFycrLGjx/v9H3t27fXL3/5S61Zs8Y+BQzAvCyGsxW3AIB6S0xM1Lp167R///56j8K1ZGlpaVq0aJG2bNmiYcOGebocAA3AGjsAcJPo6GhZLBanU6LeYNCgQbJYLJcc7QTQsjEVCwCNNGbMGIeRuv79+3uumEZISkpyeNyaGUYfgdaGqVgAAACTYCoWAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJvH/AbqLCn/VNcShAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_loc = 'test_new_exporter.dat'\n",
    "data = NewDataLoader(data_loc, particle_type='electrons')\n",
    "PS = PhaseSpace(data)\n",
    "PS.plot.energy_hist_1D()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6dd4475",
   "metadata": {},
   "source": [
    "looks good!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}