diff --git a/AniMAIRE/AniMAIRE.py b/AniMAIRE/AniMAIRE.py
index f089e42..7179ed7 100644
--- a/AniMAIRE/AniMAIRE.py
+++ b/AniMAIRE/AniMAIRE.py
@@ -202,6 +202,15 @@ def create_single_dose_map_plot_plt(heatmap_DF_to_Plot,
                                     palette="Spectral_r",
                                     plot_longitude_east=False, 
                                     plot_colorbar=True):
+    
+    if not (heatmap_DF_to_Plot["altitude (km)"].nunique() == 1):
+        print()
+        print("\033[1mWARNING: multiple altitudes were supplied in the input dataframe, therefore only the map for the maximum altitude will be plotted!\033[0m")
+        print()
+        heatmap_DF_to_Plot = heatmap_DF_to_Plot.query(f"`altitude (km)` == {heatmap_DF_to_Plot['altitude (km)'].max()}")
+    
+    if hue_range is None:
+        hue_range = (0,heatmap_DF_to_Plot["edose"].max())
 
     ############################ creating background world map and dose image
     currentFigure = plt.gcf()
diff --git a/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py b/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py
index 22e44b2..8f95f7b 100644
--- a/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py
+++ b/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py
@@ -247,7 +247,7 @@ def runOverSpecifiedAltitudes(self):
         # assign each asymptotic direction a weighting factor in accordance with its pitch angle
         print("assigning pitch angle weighting factors...")
         df_with_weighting_factors_full_angles = acquireWeightingFactors(self.dfOfAllAsymptoticDirections,
-                                                            self.particle_distribution.momentum_distribution)
+                                                            self.particle_distribution)
         #######################################################
 
         # print("df_with_weighting_factors:")
diff --git a/AniMAIRE/anisotropic_MAIRE_engine/spectralCalculations/particleSpecies.py b/AniMAIRE/anisotropic_MAIRE_engine/spectralCalculations/particleSpecies.py
index 2cc6f13..d9bef14 100644
--- a/AniMAIRE/anisotropic_MAIRE_engine/spectralCalculations/particleSpecies.py
+++ b/AniMAIRE/anisotropic_MAIRE_engine/spectralCalculations/particleSpecies.py
@@ -3,10 +3,12 @@
 class particleSpecies():
 
     particle_atomic_number_dict = {"proton":1,"alpha":2}
+    particle_atomic_mass_dict = {"proton":1,"alpha":4}
 
     def __init__(self, particleName, atomicNumber=None):
         self.particleName = particleName
         if atomicNumber == None:
             atomicNumber = self.particle_atomic_number_dict[particleName]
         
-        self.atomicNumber = atomicNumber
\ No newline at end of file
+        self.atomicNumber = atomicNumber
+        self.atomicMass = self.particle_atomic_mass_dict[particleName]
\ No newline at end of file
diff --git a/AniMAIRE/anisotropic_MAIRE_engine/utils/AsymptoticDirectionDataframe.py b/AniMAIRE/anisotropic_MAIRE_engine/utils/AsymptoticDirectionDataframe.py
index c985c83..fb9e717 100755
--- a/AniMAIRE/anisotropic_MAIRE_engine/utils/AsymptoticDirectionDataframe.py
+++ b/AniMAIRE/anisotropic_MAIRE_engine/utils/AsymptoticDirectionDataframe.py
@@ -40,7 +40,7 @@ def generate_asymp_dir_DF(dataframeToFillFrom:pd.DataFrame, IMFlatitude:float, I
 
     new_asymp_dir_DF = dataframeToFillFrom.copy()
 
-    new_asymp_dir_DF["Energy"] = PRCT.convertParticleRigidityToEnergy(dataframeToFillFrom["Rigidity"], particleMassAU = 1, particleChargeAU = 1)
+    #new_asymp_dir_DF["Energy"] = PRCT.convertParticleRigidityToEnergy(dataframeToFillFrom["Rigidity"], particleMassAU = 1, particleChargeAU = 1)
 
     print("assigning asymptotic coordinates")
     if cache == False:
@@ -132,7 +132,9 @@ def get_pitch_angle_for_DF_row(IMFlatitude, IMFlongitude, dataframeRow, datetime
     pitch_angle_for_row = calculatePitchAngle_from_IMF_dir(interplanetary_mag_field, rowInSpacepyCoords, datetime_to_run_across_UTC)
     return pitch_angle_for_row
 
-def acquireWeightingFactors(asymptotic_direction_DF:pd.DataFrame, momentaDist):
+def acquireWeightingFactors(asymptotic_direction_DF:pd.DataFrame, particle_distribution):
+
+    momentaDist = particle_distribution.momentum_distribution
 
     new_asymptotic_direction_DF = asymptotic_direction_DF.copy()
 
@@ -170,9 +172,13 @@ def acquireWeightingFactors(asymptotic_direction_DF:pd.DataFrame, momentaDist):
     #print(new_asymptotic_direction_DF)
 
     print("calculating energy + pitch combined weighting factors...")
+    new_asymptotic_direction_DF["Energy"] = PRCT.convertParticleRigidityToEnergy(new_asymptotic_direction_DF["Rigidity"], 
+                                                                      particleMassAU = particle_distribution.particle_species.atomicMass, 
+                                                                      particleChargeAU = particle_distribution.particle_species.atomicNumber)
     energySpectrum = PRCT.convertParticleRigiditySpecToEnergySpec(new_asymptotic_direction_DF["Rigidity"],
                                                                   new_asymptotic_direction_DF["fullRigidityPitchWeightingFactor"],
-                                                                  particleMassAU=1, particleChargeAU=1)
+                                                                  particleMassAU=particle_distribution.particle_species.atomicMass, 
+                                                                  particleChargeAU=particle_distribution.particle_species.atomicNumber)
 
     new_asymptotic_direction_DF["fullEnergyPitchWeightingFactor"] = energySpectrum["Energy distribution values"]
     #print(new_asymptotic_direction_DF)
diff --git a/AniMAIRE_examples.ipynb b/AniMAIRE_examples.ipynb
index 322d499..a5361ec 100644
--- a/AniMAIRE_examples.ipynb
+++ b/AniMAIRE_examples.ipynb
@@ -47,7 +47,9 @@
    "source": [
     "import numpy as np\n",
     "from AniMAIRE import AniMAIRE\n",
-    "import datetime as dt\n"
+    "import datetime as dt\n",
+    "\n",
+    "import matplotlib.pyplot as plt"
    ]
   },
   {
@@ -59,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -75,65 +77,33 @@
      "output_type": "stream",
      "text": [
       "running MAGNETOCOSMICS to acquire asymptotic directions...\n",
-      "Unexpected exception formatting exception. Falling back to standard exception\n"
+      "assigning asymptotic coordinates\n",
+      "acquiring pitch angles...\n",
+      "debug mode being used: setting AniMAIRE to use progress_apply rather than running in parallel!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 687312/687312 [01:01<00:00, 11165.23it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "successfully converted asymptotic directions\n",
+      "assigning pitch angle weighting factors...\n",
+      "calculating pitch angle weighting factors...\n",
+      "debug mode being used: setting AniMAIRE to use progress_apply rather than running in parallel!\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Traceback (most recent call last):\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3398, in run_code\n",
-      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
-      "  File \"/tmp/ipykernel_17666/3514468009.py\", line 7, in <cell line: 7>\n",
-      "    test_anisotropic_dose_rates = AniMAIRE.run_from_spectra(\n",
-      "  File \"/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py\", line 69, in run_from_spectra\n",
-      "    output_dose_rate_DF = engine_to_run.getAsymptoticDirsAndRun(use_default_9_zeniths_azimuths,**mag_cos_kwargs)\n",
-      "  File \"/home/chrisswdavis/AniMAIRE-public/AniMAIRE/anisotropic_MAIRE_engine/maireSengine.py\", line 51, in getAsymptoticDirsAndRun\n",
-      "    self.acquireDFofAllAsymptoticDirections(use_default_9_zeniths_azimuths,**mag_cos_kwargs)\n",
-      "  File \"/home/chrisswdavis/AniMAIRE-public/AniMAIRE/anisotropic_MAIRE_engine/maireSengine.py\", line 111, in acquireDFofAllAsymptoticDirections\n",
-      "    self.df_of_asymptotic_directions = generate_asymp_dir_DF(raw_asymp_dir_DF,\n",
-      "  File \"/home/chrisswdavis/AniMAIRE-public/AniMAIRE/anisotropic_MAIRE_engine/utils/AsymptoticDirectionDataframe.py\", line 44, in generate_asymp_dir_DF\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/ParticleRigidityCalculationTools.py\", line 25, in functionWithGeneralInputArgs\n",
-      "    result = functionToModify(*newArgs, **kwargs)\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/ParticleRigidityCalculationTools.py\", line 82, in convertParticleRigidityToEnergy\n",
-      "    totalParticleEnergy = np.sqrt((pc**2) + (particleRestEnergy**2))\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/pandas/core/generic.py\", line 2101, in __array_ufunc__\n",
-      "    return arraylike.array_ufunc(self, ufunc, method, *inputs, **kwargs)\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/pandas/core/arraylike.py\", line 397, in array_ufunc\n",
-      "    result = getattr(ufunc, method)(*inputs, **kwargs)\n",
-      "KeyboardInterrupt\n",
-      "\n",
-      "During handling of the above exception, another exception occurred:\n",
-      "\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 1993, in showtraceback\n",
-      "    stb = self.InteractiveTB.structured_traceback(\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1118, in structured_traceback\n",
-      "    return FormattedTB.structured_traceback(\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1012, in structured_traceback\n",
-      "    return VerboseTB.structured_traceback(\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 865, in structured_traceback\n",
-      "    formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 818, in format_exception_as_a_whole\n",
-      "    frames.append(self.format_record(r))\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 736, in format_record\n",
-      "    result += ''.join(_format_traceback_lines(frame_info.lines, Colors, self.has_colors, lvals))\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
-      "    value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/stack_data/core.py\", line 698, in lines\n",
-      "    pieces = self.included_pieces\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
-      "    value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/stack_data/core.py\", line 649, in included_pieces\n",
-      "    pos = scope_pieces.index(self.executing_piece)\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
-      "    value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/stack_data/core.py\", line 628, in executing_piece\n",
-      "    return only(\n",
-      "  File \"/home/chrisswdavis/.local/lib/python3.8/site-packages/executing/executing.py\", line 164, in only\n",
-      "    raise NotOneValueFound('Expected one value, found 0')\n",
-      "executing.executing.NotOneValueFound: Expected one value, found 0\n"
+      " 27%|██▋       | 182937/687312 [00:17<00:47, 10522.32it/s]\n"
      ]
     }
    ],
@@ -153,6 +123,3637 @@
     ")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>altitude (km)</th>\n",
+       "      <th>edose</th>\n",
+       "      <th>adose</th>\n",
+       "      <th>dosee</th>\n",
+       "      <th>tn1</th>\n",
+       "      <th>tn2</th>\n",
+       "      <th>tn3</th>\n",
+       "      <th>SEU</th>\n",
+       "      <th>SEL</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>1.976895e-07</td>\n",
+       "      <td>2.027961e-07</td>\n",
+       "      <td>3.222401e-07</td>\n",
+       "      <td>1.286575e-08</td>\n",
+       "      <td>7.877480e-09</td>\n",
+       "      <td>5.401425e-09</td>\n",
+       "      <td>7.877480e-22</td>\n",
+       "      <td>7.877480e-17</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0480</td>\n",
+       "      <td>4.838923e-07</td>\n",
+       "      <td>4.869626e-07</td>\n",
+       "      <td>7.032983e-07</td>\n",
+       "      <td>7.429541e-08</td>\n",
+       "      <td>4.866265e-08</td>\n",
+       "      <td>3.410940e-08</td>\n",
+       "      <td>4.866265e-21</td>\n",
+       "      <td>4.866265e-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>6.0960</td>\n",
+       "      <td>1.453834e-06</td>\n",
+       "      <td>1.411544e-06</td>\n",
+       "      <td>2.045308e-06</td>\n",
+       "      <td>2.472576e-07</td>\n",
+       "      <td>1.611648e-07</td>\n",
+       "      <td>1.136527e-07</td>\n",
+       "      <td>1.611648e-20</td>\n",
+       "      <td>1.611648e-15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.6200</td>\n",
+       "      <td>2.352658e-06</td>\n",
+       "      <td>2.382057e-06</td>\n",
+       "      <td>3.304989e-06</td>\n",
+       "      <td>3.720997e-07</td>\n",
+       "      <td>2.420436e-07</td>\n",
+       "      <td>1.708843e-07</td>\n",
+       "      <td>2.420436e-20</td>\n",
+       "      <td>2.420436e-15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>8.5344</td>\n",
+       "      <td>2.970462e-06</td>\n",
+       "      <td>2.791970e-06</td>\n",
+       "      <td>4.201789e-06</td>\n",
+       "      <td>4.473736e-07</td>\n",
+       "      <td>2.919136e-07</td>\n",
+       "      <td>2.063902e-07</td>\n",
+       "      <td>2.919136e-20</td>\n",
+       "      <td>2.919136e-15</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   latitude  longitude  altitude (km)         edose         adose  \\\n",
+       "0     -90.0        0.0         0.0000  1.976895e-07  2.027961e-07   \n",
+       "1     -90.0        0.0         3.0480  4.838923e-07  4.869626e-07   \n",
+       "2     -90.0        0.0         6.0960  1.453834e-06  1.411544e-06   \n",
+       "3     -90.0        0.0         7.6200  2.352658e-06  2.382057e-06   \n",
+       "4     -90.0        0.0         8.5344  2.970462e-06  2.791970e-06   \n",
+       "\n",
+       "          dosee           tn1           tn2           tn3           SEU  \\\n",
+       "0  3.222401e-07  1.286575e-08  7.877480e-09  5.401425e-09  7.877480e-22   \n",
+       "1  7.032983e-07  7.429541e-08  4.866265e-08  3.410940e-08  4.866265e-21   \n",
+       "2  2.045308e-06  2.472576e-07  1.611648e-07  1.136527e-07  1.611648e-20   \n",
+       "3  3.304989e-06  3.720997e-07  2.420436e-07  1.708843e-07  2.420436e-20   \n",
+       "4  4.201789e-06  4.473736e-07  2.919136e-07  2.063902e-07  2.919136e-20   \n",
+       "\n",
+       "            SEL  \n",
+       "0  7.877480e-17  \n",
+       "1  4.866265e-16  \n",
+       "2  1.611648e-15  \n",
+       "3  2.420436e-15  \n",
+       "4  2.919136e-15  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_anisotropic_dose_rates.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:222: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"SEU (Upsets/hr/Gb)\"] = heatmap_DF_to_Plot[\"SEU\"] * (60.0 * 60.0) * 1e9\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:223: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"SEL (Latch-ups/hr/device)\"] = heatmap_DF_to_Plot[\"SEL\"] * (60.0 * 60.0)\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:225: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"longitudeTranslated\"] = heatmap_DF_to_Plot[\"longitude\"].apply(lambda x:x-360.0 if x > 180.0 else x)\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:290: UserWarning: The following kwargs were not used by contour: 'hue_range'\n",
+      "  contours = plt.contour(contour_longs,contour_lats,interp(contour_longs, contour_lats),\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "AniMAIRE.plot_dose_map(test_anisotropic_dose_rates.query(\"`altitude (km)` == 12.1920\"),\n",
+    "                                         hue_range=(0,9))\n",
+    "\n",
+    "plt.savefig(\"Anisotropic_40kft_example.svg\",bbox_inches=\"tight\")\n",
+    "plt.savefig(\"Anisotropic_40kft_example.png\",dpi=300,bbox_inches=\"tight\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating an Isotropic Map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "running MAGNETOCOSMICS to acquire asymptotic directions...\n",
+      "assigning asymptotic coordinates\n",
+      "acquiring pitch angles...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ba143d92575046f0b37fff6fc812914e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "successfully converted asymptotic directions\n",
+      "assigning pitch angle weighting factors...\n",
+      "calculating pitch angle weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5bd68d7e4e13438ead276b11809c8ae8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating rigidity weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "53ac93385b10427095820f18e0ed6b50",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating rigidity + pitch combined weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "411e052bc72a46aebdcd8747d544d307",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating energy + pitch combined weighting factors...\n",
+      "converting spectra and asymptotic directions to particle fluxes and dose rates...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ba377fb2075440658968d0830abbe072",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=444), Label(value='0 / 444'))), HB…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output dose rates calculated successfully!\n",
+      "Success!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py:276: UserWarning: Pandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-access\n",
+      "  sortedOutputDoseRates.weighting_factor_input_DF = df_with_weighting_factors\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_isotropic_dose_rates = AniMAIRE.run_from_spectra(\n",
+    "        proton_rigidity_spectrum=lambda x:2.56*(x**-3.41),\n",
+    "        Kp_index=3,\n",
+    "        date_and_time=dt.datetime(2006, 12, 13, 3, 0),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>altitude (km)</th>\n",
+       "      <th>edose</th>\n",
+       "      <th>adose</th>\n",
+       "      <th>dosee</th>\n",
+       "      <th>tn1</th>\n",
+       "      <th>tn2</th>\n",
+       "      <th>tn3</th>\n",
+       "      <th>SEU</th>\n",
+       "      <th>SEL</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.010442</td>\n",
+       "      <td>0.012540</td>\n",
+       "      <td>0.010010</td>\n",
+       "      <td>0.004437</td>\n",
+       "      <td>0.002729</td>\n",
+       "      <td>0.001828</td>\n",
+       "      <td>2.729229e-16</td>\n",
+       "      <td>2.729229e-11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0480</td>\n",
+       "      <td>0.101786</td>\n",
+       "      <td>0.117658</td>\n",
+       "      <td>0.085755</td>\n",
+       "      <td>0.051895</td>\n",
+       "      <td>0.033617</td>\n",
+       "      <td>0.022979</td>\n",
+       "      <td>3.361684e-15</td>\n",
+       "      <td>3.361684e-10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>6.0960</td>\n",
+       "      <td>0.672702</td>\n",
+       "      <td>0.742332</td>\n",
+       "      <td>0.457695</td>\n",
+       "      <td>0.326731</td>\n",
+       "      <td>0.211853</td>\n",
+       "      <td>0.145046</td>\n",
+       "      <td>2.118530e-14</td>\n",
+       "      <td>2.118530e-09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.6200</td>\n",
+       "      <td>1.442377</td>\n",
+       "      <td>1.541670</td>\n",
+       "      <td>0.975436</td>\n",
+       "      <td>0.665785</td>\n",
+       "      <td>0.431261</td>\n",
+       "      <td>0.295516</td>\n",
+       "      <td>4.312608e-14</td>\n",
+       "      <td>4.312608e-09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>8.5344</td>\n",
+       "      <td>2.165860</td>\n",
+       "      <td>2.249419</td>\n",
+       "      <td>1.426324</td>\n",
+       "      <td>0.964791</td>\n",
+       "      <td>0.623291</td>\n",
+       "      <td>0.426927</td>\n",
+       "      <td>6.232913e-14</td>\n",
+       "      <td>6.232913e-09</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   latitude  longitude  altitude (km)     edose     adose     dosee       tn1  \\\n",
+       "0     -90.0        0.0         0.0000  0.010442  0.012540  0.010010  0.004437   \n",
+       "1     -90.0        0.0         3.0480  0.101786  0.117658  0.085755  0.051895   \n",
+       "2     -90.0        0.0         6.0960  0.672702  0.742332  0.457695  0.326731   \n",
+       "3     -90.0        0.0         7.6200  1.442377  1.541670  0.975436  0.665785   \n",
+       "4     -90.0        0.0         8.5344  2.165860  2.249419  1.426324  0.964791   \n",
+       "\n",
+       "        tn2       tn3           SEU           SEL  \n",
+       "0  0.002729  0.001828  2.729229e-16  2.729229e-11  \n",
+       "1  0.033617  0.022979  3.361684e-15  3.361684e-10  \n",
+       "2  0.211853  0.145046  2.118530e-14  2.118530e-09  \n",
+       "3  0.431261  0.295516  4.312608e-14  4.312608e-09  \n",
+       "4  0.623291  0.426927  6.232913e-14  6.232913e-09  "
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_isotropic_dose_rates.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:222: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"SEU (Upsets/hr/Gb)\"] = heatmap_DF_to_Plot[\"SEU\"] * (60.0 * 60.0) * 1e9\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:223: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"SEL (Latch-ups/hr/device)\"] = heatmap_DF_to_Plot[\"SEL\"] * (60.0 * 60.0)\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:225: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"longitudeTranslated\"] = heatmap_DF_to_Plot[\"longitude\"].apply(lambda x:x-360.0 if x > 180.0 else x)\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:290: UserWarning: The following kwargs were not used by contour: 'hue_range'\n",
+      "  contours = plt.contour(contour_longs,contour_lats,interp(contour_longs, contour_lats),\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "AniMAIRE.plot_dose_map(test_isotropic_dose_rates.query(\"`altitude (km)` == 12.1920\"),\n",
+    "                                         hue_range=(0,9))\n",
+    "\n",
+    "plt.savefig(\"Isotropic_40kft_example.svg\",bbox_inches=\"tight\")\n",
+    "plt.savefig(\"Isotropic_40kft_example.png\",dpi=300,bbox_inches=\"tight\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generating dose rates due to cosmic rays"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "running MAGNETOCOSMICS to acquire asymptotic directions...\n",
+      "assigning asymptotic coordinates\n",
+      "acquiring pitch angles...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6b80d214227647b0af0b3538cd16b10e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "successfully converted asymptotic directions\n",
+      "assigning pitch angle weighting factors...\n",
+      "calculating pitch angle weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ce35b676f7714fdea3e937a87ed29c9f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating rigidity weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9b64a0a557744ebc81528feebc935aa4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating rigidity + pitch combined weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4f4a957fc487463fa28d5fdf44656228",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating energy + pitch combined weighting factors...\n",
+      "converting spectra and asymptotic directions to particle fluxes and dose rates...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bca6166078bc49b0b3db7057859aa388",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=444), Label(value='0 / 444'))), HB…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py:276: UserWarning: Pandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-access\n",
+      "  sortedOutputDoseRates.weighting_factor_input_DF = df_with_weighting_factors\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output dose rates calculated successfully!\n",
+      "assigning pitch angle weighting factors...\n",
+      "calculating pitch angle weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2f29d83217044df298966f09aa1d1461",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating rigidity weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "66fde16f8e8a412fb53bb33dd47f61f1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating rigidity + pitch combined weighting factors...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ff9e0a6a2271418b84f17b8a2a8dbff2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=114552), Label(value='0 / 114552')…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculating energy + pitch combined weighting factors...\n",
+      "converting spectra and asymptotic directions to particle fluxes and dose rates...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "846ecd67c1d54d8bae48274ca5e45cdb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=444), Label(value='0 / 444'))), HB…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "Warning: currently using an alpha particle as input actually calculates the contribution from alpha + all simulated heavier ions, rather than just alpha particles!\n",
+      "output dose rates calculated successfully!\n",
+      "Success!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/anisotropic_MAIRE_engine/singleParticleEngineInstance.py:276: UserWarning: Pandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-access\n",
+      "  sortedOutputDoseRates.weighting_factor_input_DF = df_with_weighting_factors\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_cosmic_ray_dose_rates = AniMAIRE.run_from_DLR_cosmic_ray_model(OULU_count_rate_in_seconds=106.54,\n",
+    "                                      Kp_index=3,\n",
+    "\t\t\t\t                      date_and_time=dt.datetime(2006, 12, 13, 3, 0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>altitude (km)</th>\n",
+       "      <th>edose</th>\n",
+       "      <th>adose</th>\n",
+       "      <th>dosee</th>\n",
+       "      <th>tn1</th>\n",
+       "      <th>tn2</th>\n",
+       "      <th>tn3</th>\n",
+       "      <th>SEU</th>\n",
+       "      <th>SEL</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.070523</td>\n",
+       "      <td>0.074779</td>\n",
+       "      <td>0.105375</td>\n",
+       "      <td>0.008118</td>\n",
+       "      <td>0.004984</td>\n",
+       "      <td>0.003417</td>\n",
+       "      <td>6.697111e-16</td>\n",
+       "      <td>6.697111e-11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0480</td>\n",
+       "      <td>0.296067</td>\n",
+       "      <td>0.308723</td>\n",
+       "      <td>0.316070</td>\n",
+       "      <td>0.068962</td>\n",
+       "      <td>0.044821</td>\n",
+       "      <td>0.031155</td>\n",
+       "      <td>6.128937e-15</td>\n",
+       "      <td>6.128937e-10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>6.0960</td>\n",
+       "      <td>1.323990</td>\n",
+       "      <td>1.309065</td>\n",
+       "      <td>1.215236</td>\n",
+       "      <td>0.320420</td>\n",
+       "      <td>0.208996</td>\n",
+       "      <td>0.145856</td>\n",
+       "      <td>2.894982e-14</td>\n",
+       "      <td>2.894982e-09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.6200</td>\n",
+       "      <td>2.457785</td>\n",
+       "      <td>2.382526</td>\n",
+       "      <td>2.173448</td>\n",
+       "      <td>0.564336</td>\n",
+       "      <td>0.367764</td>\n",
+       "      <td>0.257271</td>\n",
+       "      <td>5.131596e-14</td>\n",
+       "      <td>5.131596e-09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-90.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>8.5344</td>\n",
+       "      <td>3.381634</td>\n",
+       "      <td>3.148411</td>\n",
+       "      <td>2.930001</td>\n",
+       "      <td>0.749637</td>\n",
+       "      <td>0.488290</td>\n",
+       "      <td>0.342016</td>\n",
+       "      <td>6.837349e-14</td>\n",
+       "      <td>6.837349e-09</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   latitude  longitude  altitude (km)     edose     adose     dosee       tn1  \\\n",
+       "0     -90.0        0.0         0.0000  0.070523  0.074779  0.105375  0.008118   \n",
+       "1     -90.0        0.0         3.0480  0.296067  0.308723  0.316070  0.068962   \n",
+       "2     -90.0        0.0         6.0960  1.323990  1.309065  1.215236  0.320420   \n",
+       "3     -90.0        0.0         7.6200  2.457785  2.382526  2.173448  0.564336   \n",
+       "4     -90.0        0.0         8.5344  3.381634  3.148411  2.930001  0.749637   \n",
+       "\n",
+       "        tn2       tn3           SEU           SEL  \n",
+       "0  0.004984  0.003417  6.697111e-16  6.697111e-11  \n",
+       "1  0.044821  0.031155  6.128937e-15  6.128937e-10  \n",
+       "2  0.208996  0.145856  2.894982e-14  2.894982e-09  \n",
+       "3  0.367764  0.257271  5.131596e-14  5.131596e-09  \n",
+       "4  0.488290  0.342016  6.837349e-14  6.837349e-09  "
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_cosmic_ray_dose_rates.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:222: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"SEU (Upsets/hr/Gb)\"] = heatmap_DF_to_Plot[\"SEU\"] * (60.0 * 60.0) * 1e9\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:223: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"SEL (Latch-ups/hr/device)\"] = heatmap_DF_to_Plot[\"SEL\"] * (60.0 * 60.0)\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:225: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  heatmap_DF_to_Plot[\"longitudeTranslated\"] = heatmap_DF_to_Plot[\"longitude\"].apply(lambda x:x-360.0 if x > 180.0 else x)\n",
+      "/home/chrisswdavis/AniMAIRE-public/AniMAIRE/AniMAIRE.py:290: UserWarning: The following kwargs were not used by contour: 'hue_range'\n",
+      "  contours = plt.contour(contour_longs,contour_lats,interp(contour_longs, contour_lats),\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "AniMAIRE.plot_dose_map(test_cosmic_ray_dose_rates.query(\"`altitude (km)` == 12.1920\"),\n",
+    "                                         hue_range=(0,9))\n",
+    "\n",
+    "plt.savefig(\"Cosmic_ray_40kft_example.svg\",bbox_inches=\"tight\")\n",
+    "plt.savefig(\"Cosmic_ray_40kft_example.png\",dpi=300,bbox_inches=\"tight\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,