2024_06_04c_vph_vivarium_nonlinear_risk_2_salt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e02ba2a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)  # it would be great to update vivarium to make this unnecessary!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "11db1f55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon Jun 10 13:17:59 PDT 2024\r\n"
     ]
    }
   ],
   "source": [
    "import numpy as np, matplotlib.pyplot as plt, pandas as pd\n",
    "pd.set_option('display.max_rows', 8)\n",
    "!date"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306fe3c0",
   "metadata": {},
   "source": [
    "# I got some additinal informaiton from Dan Kapner and Eli Weiss\n",
    "\n",
    "tmred draws from a distribution, which they did not save a seed for in GBD 2021; they will in 2023.\n",
    "\n",
    "Can't match individual draws, but can match in distribution.\n",
    "\n",
    "Some risks have a more complicated approach.\n",
    "\n",
    "Still seems a little sus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a536915",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Config: 'input_data:\n",
      "    cache_data:\n",
      "        base: True\n",
      "    intermediary_data_cache_path:\n",
      "        base: /share/scratch/users/{username}/cache'\n",
      "Cache Dir: '/share/scratch/users/abie/cache'\n"
     ]
    }
   ],
   "source": [
    "# the Artifact class is defined in the base vivarium module\n",
    "import vivarium as vi\n",
    "\n",
    "# for creating the population and disese model components of the sim we will use vivarium_public_health\n",
    "import vivarium_public_health as vph\n",
    "\n",
    "# and to get the data for the artifact, we will use vivarium_inputs and gbd_mapping\n",
    "# note that vivarium_inputs only works when on the IHME VPN at present\n",
    "import vivarium_inputs as vii, gbd_mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3519856b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-rw-r-- 1 abie Domain Users 205K Jun  4 09:27 /share/scratch/users/abie/salt.hdf\r\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/homes/abie/.conda/envs/vivarium_nih_us_cvd/lib/python3.11/site-packages/vivarium/framework/artifact/artifact.py:69: UserWarning: No artifact found at /share/scratch/users/abie/salt.hdf. Building new artifact.\n",
      "  warnings.warn(f\"No artifact found at {path}. Building new artifact.\")\n"
     ]
    }
   ],
   "source": [
    "fname = '/share/scratch/users/abie/salt.hdf'\n",
    "!ls -halt $fname\n",
    "location = 'Washington'\n",
    "\n",
    "\n",
    "# for this example, we will create a new artifact from scratch\n",
    "!rm $fname\n",
    "art = vi.Artifact(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1a57c97b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RiskFactor(\n",
       "name='high_body_mass_index',\n",
       "kind='risk_factor',\n",
       "gbd_id=rei_id(108),\n",
       "level=2,\n",
       "most_detailed=False,\n",
       "population_attributable_fraction_calculation_type='aggregation',\n",
       "restrictions=Restrictions(\n",
       "male_only=False,\n",
       "female_only=False,\n",
       "yll_only=False,\n",
       "yld_only=False,\n",
       "yll_age_group_id_start=238.0,\n",
       "yll_age_group_id_end=235.0,\n",
       "yld_age_group_id_start=238.0,\n",
       "yld_age_group_id_end=235.0),\n",
       "affected_causes=[all_causes, communicable_maternal_neonatal_and_nutritional_diseases, tuberculosis, non_communicable_diseases, neoplasms, liver_cancer, liver_cancer_due_to_hepatitis_b, liver_cancer_due_to_hepatitis_c, liver_cancer_due_to_alcohol_use, liver_cancer_due_to_other_causes, breast_cancer, uterine_cancer, colon_and_rectum_cancer, gallbladder_and_biliary_tract_cancer, pancreatic_cancer, ovarian_cancer, kidney_cancer, thyroid_cancer, non_hodgkin_lymphoma, multiple_myeloma, leukemia, cardiovascular_diseases, ischemic_heart_disease, stroke, ischemic_stroke, intracerebral_hemorrhage, subarachnoid_hemorrhage, hypertensive_heart_disease, atrial_fibrillation_and_flutter, aortic_aneurysm, lower_extremity_peripheral_arterial_disease, chronic_respiratory_diseases, asthma, digestive_diseases, gallbladder_and_biliary_diseases, neurological_disorders, alzheimers_disease_and_other_dementias, diabetes_mellitus, chronic_kidney_disease, chronic_kidney_disease_due_to_hypertension, chronic_kidney_disease_due_to_glomerulonephritis, chronic_kidney_disease_due_to_other_and_unspecified_causes, musculoskeletal_disorders, osteoarthritis, low_back_pain, gout, sense_organ_diseases, cataract, acute_lymphoid_leukemia, chronic_lymphoid_leukemia, acute_myeloid_leukemia, chronic_myeloid_leukemia, drug_susceptible_tuberculosis, other_leukemia, multidrug_resistant_tuberculosis_without_extensive_drug_resistance, extensively_drug_resistant_tuberculosis, respiratory_infections_and_tuberculosis, diabetes_and_kidney_diseases, diabetes_mellitus_type_2, blindness_and_vision_loss, chronic_kidney_disease_due_to_diabetes_mellitus_type_2, burkitt_lymphoma, other_non_hodgkin_lymphoma, osteoarthritis_hip, osteoarthritis_knee, total_burden_related_to_hepatitis_b, total_burden_related_to_hepatitis_c, total_cancers, total_cancers_excluding_non_melanoma_skin_cancer],\n",
       "population_attributable_fraction_of_one_causes=[],\n",
       "parent=metabolic_risks,\n",
       "sub_risk_factors=[high_body_mass_index_in_adults, high_body_mass_index_in_children])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "risk = gbd_mapping.risk_factors.high_body_mass_index\n",
    "cause = gbd_mapping.causes.ischemic_heart_disease\n",
    "risk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "baa686fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m2024-06-04 11:33:55.843\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "\u001b[32m2024-06-04 11:33:57.259\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:33:57.263\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:33:57.304\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:33:57.308\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "\u001b[32m2024-06-04 11:33:58.169\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "\u001b[32m2024-06-04 11:33:58.722\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:33:58.726\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utility_data.py:86: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"draw_{i}\"] = value\n",
      "\u001b[32m2024-06-04 11:33:59.471\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:33:59.479\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:00.665\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'year_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:00.855\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:00.861\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:00.981\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'year_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.212\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.219\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.373\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'year_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.579\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.586\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.711\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'year_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.766\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:01.769\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "\u001b[32m2024-06-04 11:34:02.229\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:02.353\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:02.357\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_age_group_ids\u001b[0m:\u001b[36m2125\u001b[0m - \u001b[33m\u001b[1mData contains additional age groups beyond those specified by restriction range.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n"
     ]
    }
   ],
   "source": [
    "# It would be cool to extend vivarium_inputs methods to accept a list of locations.\n",
    "# Currently, it is necessary to create a separate artifact for each location of interest.\n",
    "\n",
    "art.write('population.location', location)\n",
    "\n",
    "df = vii.get_population_structure(location)\n",
    "art.write('population.structure', df)\n",
    "\n",
    "df = vii.get_demographic_dimensions(location)\n",
    "art.write('population.demographic_dimensions', df)\n",
    "\n",
    "# Calculating DALYs uses the theoretical minimu risk life expectancy (TMREL)\n",
    "# and the mortality component in vivarium_public_health expect this to be \n",
    "# in the artifact as well\n",
    "\n",
    "df = vii.get_theoretical_minimum_risk_life_expectancy()\n",
    "art.write('population.theoretical_minimum_risk_life_expectancy', df)\n",
    "\n",
    "# All-cause mortality is an important model parameter\n",
    "# and vivarium_public_health includes components to\n",
    "# work with it, which use the all-casuse mortality rate\n",
    "# from the artifact with the key cause.all_causes.cause_specific_mortality_rate\n",
    "\n",
    "df = vii.get_measure(gbd_mapping.causes.all_causes, 'cause_specific_mortality_rate', location)\n",
    "art.write('cause.all_causes.cause_specific_mortality_rate', df.loc[location])  # TODO: it is annoying that the location needs to be stripped from the dataframe\n",
    "\n",
    "df = vii.get_measure(gbd_mapping.covariates.live_births_by_sex, 'estimate', location)\n",
    "art.write('covariate.live_births_by_sex.estimate',\n",
    "          df.loc[location])  # TODO: it is annoying that the location needs to be stripped from the dataframe\n",
    "\n",
    "for measure in [#'remission_rate',\n",
    "                'incidence_rate',\n",
    "                'cause_specific_mortality_rate',\n",
    "                'prevalence',\n",
    "                'disability_weight',\n",
    "                'excess_mortality_rate',\n",
    "               ]:\n",
    "    df = vii.get_measure(cause, measure, location)\n",
    "    key = f'cause.{cause.name}.{measure}'\n",
    "    art.write(key, df.loc[location]) # TODO: it is annoying that the location needs to be stripped from the dataframe\n",
    "    \n",
    "# the vph.SI cause model also needs data on \"restrictions\" about the disease\n",
    "# (e.g. Cervical Cancer occurs only in Females) which must be stored in the\n",
    "# artifact as well.\n",
    "\n",
    "key = f'cause.{cause.name}.restrictions'\n",
    "restriction_dict = cause.restrictions.to_dict()\n",
    "art.write(key, restriction_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6f19a8d7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m2024-06-04 11:34:03.699\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.shared\u001b[0m:\u001b[36mcheck_value_columns_boundary\u001b[0m:\u001b[36m82\u001b[0m - \u001b[33m\u001b[1mData contains values below the expected boundary value (3.0).\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "\u001b[32m2024-06-04 11:34:04.522\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'model_version_id'}.\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:04.569\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.shared\u001b[0m:\u001b[36mcheck_value_columns_boundary\u001b[0m:\u001b[36m82\u001b[0m - \u001b[33m\u001b[1mData contains values below the expected boundary value (3.0).\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/utilities.py:487: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  data[f\"{split_column_prefix}_end\"] = [\n",
      "\u001b[32m2024-06-04 11:34:06.087\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.shared\u001b[0m:\u001b[36mcheck_value_columns_boundary\u001b[0m:\u001b[36m82\u001b[0m - \u001b[33m\u001b[1mData contains values below the expected boundary value (3.0).\u001b[0m\n",
      "\u001b[32m2024-06-04 11:34:08.336\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_columns\u001b[0m:\u001b[36m2004\u001b[0m - \u001b[33m\u001b[1mData returned extra columns: {'version_id'}.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "\u001b[32m2024-06-04 11:34:19.747\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mvivarium_inputs.validation.raw\u001b[0m:\u001b[36mcheck_paf_rr_exposure_age_groups\u001b[0m:\u001b[36m1896\u001b[0m - \u001b[33m\u001b[1mYLDs paf for ischemic_heart_disease and diet_high_in_sodium have data for the age groups: {32, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 31, 30, 235}, which do not have either relative risk or exposure data.\u001b[0m\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age_groups = set(df[op(df, tmrel)].reset_index().age_group_id)\n",
      "/mnt/share/homes/abie/projects/2024/vivarium_inputs/src/vivarium_inputs/validation/raw.py:1791: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  exposed_age